{"id":8957,"date":"2012-05-22T12:24:11","date_gmt":"2012-05-22T10:24:11","guid":{"rendered":"http:\/\/www.devapp.it\/wordpress\/?p=8957"},"modified":"2012-05-24T11:55:13","modified_gmt":"2012-05-24T09:55:13","slug":"t109-key-value-observing-costruiamo-un-semplice-lettore-multimediale","status":"publish","type":"post","link":"https:\/\/www.devapp.it\/wordpress\/t109-key-value-observing-costruiamo-un-semplice-lettore-multimediale\/","title":{"rendered":"T#109 – Key-Value Observing: Costruiamo un semplice lettore multimediale"},"content":{"rendered":"

Se si potesse stilare una classifica dei meccanismi meno conosciuti di Cocoa, il Key-Value Observing pattern<\/strong> o KVO<\/strong> sicuramente ricoprirebbe uno dei primi posti. KVO \u00e8 un meccanismo molto utile che permette agli oggetti di essere notificati rispetto a cambiamenti di specifiche propriet\u00e0 di altri oggetti. Come \u00e8 facile immaginare, questo genere di meccanismi si prestano molto bene al pattern di programmazione Model-View-Controller<\/strong>. In quest’articolo cercheremo di capire meglio come usare questa tecnica affiancando la teoria ad un esempio pratico che ne dimostri appieno le funzionalit\u00e0.<\/p>\n

Cosa vogliamo realizzare.<\/h4>\n

Visto che una delle cose che mi viene chiesta pi\u00f9 spesso \u00e8 la costruzione di un lettore MP3 personalizzato, per l’esempio di quest’articolo ho pensato di sfruttare KVO per costruire un semplice e snello lettore di stream audio per web radio.
\nIn letteratura e sul web esistono tanti esempi di lettori streaming per iOS. Il pi\u00f9 famoso di essi \u00e8 sicuramente quello descritto da Matt Gallagher<\/strong> nel suo articolo “Streaming and
\nplaying an MP3 stream<\/em>” [http:\/\/cocoawithlove.com\/2008\/09\/streaming-and-playinglive-
\nmp3-stream.html<\/a>]. Il metodo descritto da Matt nel suo articolo si basa su un complesso meccanismo di download e caching gestito da CFSocket<\/strong>. Sebbene il risultato ottenuto sia egregio, l’inclusione o l’adattamento del progetto a particolari casi d’uso pu\u00f2 risultare molto laborioso per via della natura stessa dell’approccio. Nel nostro articolo, invece, sfrutteremo un oggetto nativo di Cocoa: AVPlayer<\/strong>. Il risultato sar\u00e0 una classe facilmente trasportabile che potremo includere in qualunque progetto, sia esso destinato al mondo iOS o al mondo Mac. Per trarre il massimo profitto da quest’approccio, faremo uso del meccanismo KVO unitamente alla costruzione di un protocollo adhoc.<\/p>\n

Prima di andare avanti, proviamo a semplificare con una grafica quello che vogliamo ottenere.<\/p>\n

<\/p>\n
\"Key-Value-Observing-kvo-costruire-un-lettore-mp3-ios-01\"<\/a><\/p>\n

Fig. 1 – Diagramma di massima del nostro oggetto<\/p>\n<\/div>\n

<\/center><\/p>\n

<\/p>\n
\"Key-Value-Observing-kvo-costruire-un-lettore-mp3-ios-02\"<\/a><\/p>\n

Fig.2 – Spaccato del Model e sue interazioni con il mondo esterno<\/p>\n<\/div>\n

<\/center><\/p>\n

Il nostro oggetto, CPStreamPlayer, dovr\u00e0 essere in grado di notificare i cambiamento di stato (titolo del brano in riproduzione, buffer in esaurimento, buffer riempito, etc.) all’interfaccia grafica o a qualunque altro oggetto ne faccia richiesta. Per ottenere questo scopo utilizzeremo un pattern di programmazione molto interessante esposto dal framework Cocoa, denominato Key-Value Coding<\/strong>. <\/p>\n

KVC<\/strong> \u00e8 un meccanismo che permette di impostare o leggere un valore di variabile usando il nome stesso. Il nome \u00e8 una semplice stringa e ci riferiremo ad essa con il termine chiave o key. Ogni oggetto che eredita da NSObject pu\u00f2 fare accesso alle sue propriet\u00e0 attraverso coppie chiave-valore.<\/p>\n

Cosa significa? <\/p>\n

Immaginate di avere un oggetto che espone una propriet\u00e0 denominata ‘title’. Per poter configurare a dovere questa propriet\u00e0 \u00e8 possibile usare il tradizionale costrutto:<\/p>\n

\r\n[myObject setTitle: @\"qualcosa\"];\r\n<\/pre>\n
oppure, seguendo la notazione dotted introdotta da Objective-C 2.0:<\/p>\n
\r\nmyObject.title = @\"qualcosa\";\r\n<\/pre>\n
esiste un’altro metodo che sfrutta il concetto di Key-Value Coding:<\/p>\n
\r\n[myObject setValue:@\"qualcosa\" forKey:@\"title\"];\r\n<\/pre>\n
Allo stesso modo, se vorremo recuperare il valore della propriet\u00e0 title potremo usare i costrutti noti di Objective-C, oppure fare ricorso al meccanismo KVC:<\/p>\n
\r\nNSString *myTitle = [myObject valueForKey:@\"title\"];\r\n<\/pre>\n
A questo punto dell’articolo potrebbe venire naturale una domanda: perch\u00e9 stiamo introducendo un nuovo modo per impostare e recuperare il valore delle propriet\u00e0? Non bastano i metodi gi\u00e0 noti?<\/p>\n
Per poter rispondere a questa domanda \u00e8 necessario introdurre un altro concetto che snoccioleremo nel corso dell’articolo: Il meccanismo di Key-Value Observing o KVO. Ogni oggetto che configura le sue propriet\u00e0 attraverso il meccanismo sopra esposto di KVC, pu\u00f2 fare uso del meccanismo di KVO. Questo meccanismo permette di osservare gli eventuali cambiamenti delle propriet\u00e0 di un oggetto da un’altro oggetto, nell’ipotesi di alterare i valori delle propriet\u00e0 attraverso il meccanismo di KVC.<\/p>\n
NSNotificationCenter e Key-Value Observing<\/h4>\n
Alcuni di voi avranno gi\u00e0 avuto modo di dialogare ed interagire con le notifiche. Questa soluzione coinvolge il centro di notifica o NSNotificationCenter<\/strong>. In questo approccio, il nostro oggetto CPStreamPlayer invier\u00e0 dei messaggi al centro di notifica che, a sua volta, girer\u00e0 queste informazioni a tutti gli oggetti che si sono registrati per riceverle.<\/p>\n
Ritornando al nostro esempio, sfruttando questo approccio, le entit\u00e0 coinvolte saranno tre: NSNotificationCenter, CPStreamPlayer e gli eventuali Observer.<\/p>\n
Nell’approccio con KVO, invece, quello che faremo sar\u00e0 aggiungere un observer sull’oggetto player, in
\nmaniera da essere notificati direttamente in base a quello che succede dietro le quinte dell’oggetto CPStreamPlayer. In quest’ultimo caso, le entit\u00e0 coinvolte saranno due: CPStreamPlayer ed Observer.<\/p>\n
<\/p>\n
\"Key-Value-Observing-kvo-costruire-un-lettore-mp3-ios-03\"<\/a><\/p>\n
Fig.3 – Pattern di notifica basato su NSNotificationCenter.<\/p>\n<\/div>\n
<\/center><\/p>\n
<\/p>\n
\"Key-Value-Observing-kvo-costruire-un-lettore-mp3-ios-04\"<\/a><\/p>\n
Fig.4- Pattern di notifica basato su Key-Value Observing.<\/p>\n<\/div>\n
<\/center><\/p>\n
Sebbene entrambi i pattern di programmazione sembrano essere simili, il loro funzionamento a basso livello \u00e8 molto diverso. Come regola generale di programmazione il pattern con Notification Center dovrebbe essere impiegato solo quando sussiste l’esigenza di notificare uno stesso messaggio a pi\u00f9 osservatori assolutamente slegati tra loro. Questi messaggi dovrebbero essere di tipo allarme e tutto l’overhead di trasferire informazioni aggiuntive sar\u00e0 a carico nostro, attraverso il concetto di NSNotification e dizionario di userInfo (vedremo questo pattern di programmazione in dettaglio in un altro articolo). <\/p>\n
Inoltre, utilizzando un’entit\u00e0 esterna (NSNotificationCenter) le comunicazioni tra gli oggetti potrebbero essere ritardate, causando dei piccoli glitch sulla nostra user interface. La comunicazione KVO, invece, non coinvolge altri attori ed \u00e8 diretta tra i due oggetti che la instaurano. Diremo che due oggetti che fanno KVO tra loro sono legati o “bindati”.<\/p>\n
Un ultima considerazione relativamente all’oggetto che cercheremo di costruire nel nostro articolo. Per rendere il nostro esempio il pi\u00f9 portabile possibile, costruiremo un oggetto wrapper a pi\u00f9 alto livello, che si preoccuper\u00e0 per noi di dialogare con AVPlayer.<\/p>\n
Nella grafica sotto \u00e8 mostrata una semplificazione di quello che sar\u00e0 la classe CPStreamPlayer insieme al meccanismo di Key-Value Observing:<\/p>\n
<\/p>\n
\"Key-Value-Observing-kvo-costruire-un-lettore-mp3-ios-05\"<\/a><\/p>\n
Fig.5 – Semplificazione classe CPStreamPlayer e suoi oggetti interni.<\/p>\n<\/div>\n
<\/center><\/p>\n
<\/p>\n
\"Key-Value-Observing-kvo-costruire-un-lettore-mp3-ios-06\"<\/a><\/p>\n
Fig. 6 – KVO tra la classe CPStreamPlayer e le sue istanze interne.<\/p>\n<\/div>\n
<\/center><\/p>\n
KVO in pratica<\/h4>\n
Ci sono tre passi da effettuare per configurare correttamente un osservatore.<\/p>\n
    \n
  1. Prima di tutto, bisogna accertarsi di essere davanti ad uno scenario in cui l’approccio KVO risulti utile. Ad esempio, un oggetto che ha bisogno di essere notificato quando viene effettuata una modifica ad una propriet\u00e0 di un altro oggetto. Nel nostro caso, l’oggetto CPStreamPlayer dovr\u00e0 essere a conoscenza dei cambiamenti che avvengono sullo stream attualmente in corso gestito dagli oggetti AVPlayer ed AVPlayerItem.<\/li>\n
  2. L’oggetto CPStreamPlayer deve registrarsi come osservatore sugli oggetti che intende monitorare, inviando un messaggio addObserver:forKeyPath:options:context:<\/strong>
    \nIl messaggio addObserver:forKeyPath:options:context: stabilisce una interconnessione tra gli oggetti che specifichiamo. La connessione non viene specificata tra le due classi, bens\u00ec tra le istanza degli oggetti a runtime. Tornando al nostro esempio, l’oggetto wrapper CPStreamPlayer sar\u00e0 osservatore dei suoi oggetti privati in maniera da poterne monitorare lo stato.<\/li>\n
  3. Per rispondere alle notifiche di cambiamento, l’osservatore deve implementare il metodo observeValueForKeyPath:ofObject:change:context:<\/strong>
    \nQuesto metodo definisce come l’osservatore risponde alle notifiche di cambiamento. In pratica, \u00e8 il metodo su cui dobbiamo lavorare per reagire ai cambiamenti che arriveranno.
    \nIl metodo observeValueForKeyPath:ofObject:change:context: viene invocato automaticamente quando una propriet\u00e0 risulta modificata seguendo lo standard KVO.<\/li>\n<\/ol>\n
    Il primo beneficio di quest’approccio consiste sicuramente nel non (re)implementare un nostro personale schema per l’invio di notifiche ogni qualvolta una propriet\u00e0 dei nostri oggetti verr\u00e0 cambiata. Tipicamente non ci sono altre azioni oltre a quelle elencate nei quattro passi sopra per adottare il meccanismo di notifica basato su KVO. A differenza del meccanismo di notifica centrale attraverso NSNotificationCenter, inoltre, le notifiche vengono inviate direttamente agli osservatori registrati. NSObject fornisce un’implementazione base per questo meccanismo e, raramente, si avr\u00e0 l’esigenza di
    \nmodicarne l’implementazione.<\/p>\n
    AVPlayer ed AVItem – Come funzionano gli stream MP3<\/h4>\n
    Dalla versione 4.0, iOS mette a disposizione un oggetto utilissimo per la fruizione di contenuti multimediali, compresi quelli che arrivano da un flusso MP3 trasmesso via http.
    \nL’oggetto in questione si chiama AVPlayer<\/strong>. Esso funziona equamente bene sia con oggetti
    \nlocali che con oggetti remoti e\/o in stream. E’ possibile anche creare una playlist con oggetti multipli ed avere controllo sui singoli elementi.<\/p>\n
    L’organizzazione degli oggetti relativamente ad uno stream musicale pu\u00f2 essere semplificata nel seguente diagramma:<\/p>\n

    \n    \"Key-Value-Observing-kvo-costruire-un-lettore-mp3-ios-07\"<\/a>
    \n<\/center><\/p>\n
    La prima cosa da fare per poter sfruttare l’oggetto AVPlayer \u00e8 allocarne un’istanza generica in memoria:<\/p>\n
    \r\nplayer = [[AVPlayer alloc] init];\r\n<\/pre>\n
    Il prossimo passo \u00e8 quello di creare un’istanza di AVPlayerItem, ovvero un’istanza che conosca cosa vogliamo suonare (file locale o stream remoto). Nel nostro caso, passeremo ad AVPlayerItem un oggetto NSURL, contenente la stringa dell’endpoint http remoto da suonare.<\/p>\n
    \r\nNSURL *streamUrl = [NSURL URLWithString:streamAddress];\r\nAVPlayerItem *anItem = [AVPlayerItem playerItemWithURL:streamUrl];\r\n<\/pre>\n
    Una volta ottenuta un’istanza valida di AVPlayerItem possiamo rimpiazzare il currentItem della nostra istanza di AVPlayer, come segue:<\/p>\n
    \r\n[player replaceCurrentItemWithPlayerItem:anItem];\r\n<\/pre>\n
    Infine, lanciamo un messaggio di play all’istanza di AVPlayer, per iniziare la riproduzione:<\/p>\n
    \r\n[player play];\r\n<\/pre>\n
    E’ necessario spendere qualche altra parola relativamente alle modalit\u00e0 di streaming MP3.
    \nI server di stream MP3, tipicamente, seguono una falsa riga incentrata su un sistema di unicast per ogni singolo client connesso. In pratica, ogni cliente che richiede lo stream avr\u00e0 riservato un suo spazio per lo streaming ma non potr\u00e0 comunicare con il server. <\/p>\n
    Per poter costruire un lettore da zero, sarebbe necessario scendere in dettaglio, relativamente alla codifica dei dati ricevuti e come vengono generati i blocchi (chunks) di informazione. Questa \u00e8 una della parti pi\u00f9 corpose dell’articolo di Matt Gallagher a cui mi riferivo sopra. Visto che noi useremo un oggetto a pi\u00f9 alto livello, disponibile nel framework Cocoa\/CocoaTouch, non avremo bisogno di scendere a questo livello di dettaglio. Ci baster\u00e0 conoscere l’indirizzo http dello stream che vogliamo usare. <\/p>\n
    Risolto questo problema, se ne presenta un’altro non di meno conto. Uno stream di dati ha alcune difficolt\u00e0 concettuali da risolvere. I dati, infatti, vengono inseriti in un buffer tampone che serve per evitare un’interruzione dell’ascolto in caso di un’improvviso calo di banda nel nostro dispositivo. Questo buffer viene aggiustato dinamicamente in funzione delle condizioni di banda ed il lettore deve adattarsi a queste condizioni dinamiche.<\/p>\n
    Un altro aspetto che merita attenzione riguarda l’aggiornamento del brano attualmente in ascolto.
    \nGli attuali sistemi di stream permettono l’invio di un pacchetto ad inizio brano, unitamente ai dati dell’audio, contenente le informazioni relative al brano attualmente in riproduzione.<\/p>\n
    L’idea \u00e8 quella di aggiornare la nostra vista soltanto quando se ne verifica una reale esigenza (ad esempio, quando cambia il brano del nostro stream o quando stiamo effettuando il buffering dello stream). E’ in questo contesto che trova spazio quanto esposto relativamente a KVO e KVC. Senza un meccanismo di questo tipo, infatti, l’aggiornamento del brano attualmente riprodotto diventerebbe una sfida senza soluzioni. Se aggiornassimo il titolo ad intervalli regolari, ci troveremmo quasi sempre in una condizione di inconsistenza tra il brano riprodotto e quello visualizzato, stessa cosa per quanto riguarda i messaggi di sistema relativi al buffering. Ancora, utilizzando un paradigma basato sul polling ad intervalli regolari, tutta la user interface ne risentirebbe a livello di fluidit\u00e0 e reattivit\u00e0.<\/p>\n
    Supponendo che l’istanza di AVPlayerItem da suonare sia denominata anItem, potremo cos\u00ec procedere:<\/p>\n
    \r\n[anItem addObserver:self\r\n         forKeyPath:@\"timedMetadata\"\r\n            options:NSKeyValueObservingOptionNew\r\n            context:NULL];\r\n<\/pre>\n
    In questo modo, la classe CPStreamPlayer (self), sar\u00e0 notificata relativamente a nuovi cambiamenti (NSKeyValueObservingOptionNew) che intervengono per le propriet\u00e0 elencate sopra. I pi\u00f9 attenti di voi avranno notato che il metodo utilizzato non \u00e8 quello precedentemente illustrato ma una sua variante denominata addObserver:forKeyPath:options:context:<\/strong> che prende come parametro un keypath
    \ne non una chiave.<\/p>\n
    Cosa \u00e8 un Keypath?<\/p>\n
    Semplicemente \u00e8 un percorso di chiavi, separate da punti, che esprimono un percorso sino ad arrivare ad una particolare propriet\u00e0. Visto che le propriet\u00e0 che stiamo cercando sono direttamente esposte dall’istanza dell’oggetto AVPlayerItem, nel nostro caso il keypath corrisponder\u00e0 con la key.<\/p>\n
    A questo punto l’istanza di CPStreamPlayer sar\u00e0 legate all’istanza di AVPlayerItem denominata anItem. Questo significa che qualunque cambiamento delle propriet\u00e0 sopra elencate, scatener\u00e0 un messaggio observeValueForKeyPath:ofObject:change:context:<\/strong> sull’oggetto observer CPStreamPlayer.<\/p>\n
    Ci resta dunque da implementare questo metodo e la relativa logica per reagire ai singoli eventi:<\/p>\n
    \r\n- (void)observeValueForKeyPath:(NSString *)keyPath\r\n                      ofObject:(id)object\r\n                        change:(NSDictionary *)change\r\n                       context:(void *)context\r\n{\r\n    if([keyPath rangeOfString:@\"playbackBufferEmpty\"].location != NSNotFound && self.isPlaying)\r\n    {\r\n        [player pause];\r\n    }\r\n    if([keyPath rangeOfString:@\"playbackLikelyToKeepUp\"].location != NSNotFound)\r\n    {\r\n        [player play];\r\n    }\r\n    else if([keyPath rangeOfString:@\"timedMetadata\"].location != NSNotFound)\r\n    {\r\n        if([[change objectForKey:@\"new\"] isKindOfClass:[NSArray class]])\r\n        {\r\n            \/\/update songTitle and Artist\r\n        }\r\n    }\r\n}\r\n<\/pre>\n
    Nel caso di playbackBufferEmpty, metteremo in pausa l’istanza del player e proveremo a lanciare un messaggio di CPStreamPlayerDidPaused al delegato designato. Nel caso di playbackLikelyToKeeup, ossia quando il buffer \u00e8 quasi pieno, ripristineremo l’ascolto.
    \nInfine, nel caso di una variazione alla propriet\u00e0 timedMetadata, ossia quando variano i metadati associati allo stream, reagiremo popolando correttamente i corrispondenti campi del brano: titolo ed artista.<\/p>\n
    UIViewController e gestione del player<\/h4>\n
    Ci resta da gestire il controllore di vista, responsabile del player. Anche in questo caso, si tratter\u00e0 di un’operazione davvero semplice. La classe CPStreamPlayer, implementa un protocollo informale:<\/p>\n
    \r\n@protocol CPStreamPlayerDelegate\r\n@optional\r\n- (void)CPStreamPlayerDidStarted:(CPStreamPlayer *)actPlayer;\r\n- (void)CPStreamPlayerDidPaused:(CPStreamPlayer *)actPlayer;\r\n- (void)CPStreamPlayerMetadataDidUpdated:(CPStreamPlayer *)actPlayer;\r\n@end\r\n<\/pre>\n
    La nostra istanza di UIViewController dovr\u00e0 implementarlo se desidera ricevere notifiche relativamente a start e stop dello stream e cambiamento dei metadati. Nel nostro esempio base, ci baster\u00e0 aggiornare il titolo del pulsante di play ed i campi che indicano il brano in riproduzione:<\/p>\n
    \r\n#pragma mark -\r\n#pragma mark CPStreamPlayerDelegate\r\n\r\n- (void)CPStreamPlayerDidStarted:(CPStreamPlayer *)actPlayer {\r\n    [aButton setTitle:@\"Buffering\" forState:UIControlStateNormal];\r\n}\r\n- (void)CPStreamPlayerDidPaused:(CPStreamPlayer *)actPlayer {\r\n    [aButton setTitle:@\"Play\" forState:UIControlStateNormal];\r\n}\r\n- (void)CPStreamPlayerMetadataDidUpdated:(CPStreamPlayer *)actPlayer {\r\n    [aButton setTitle:@\"Stop\" forState:UIControlStateNormal];\r\n    songTitle.text = actPlayer.songTitle;\r\n    songArtist.text = actPlayer.artistTitle;\r\n    channel.text = actPlayer.channelTitle;\r\n}\r\n<\/pre>\n
    Un ultimo tocco: il controllo remoto<\/h4>\n
    iOS ci permette di sfruttare i controlli multimediali disponibili sulla cuffia o quelli che compaiono quando il telefono \u00e8 bloccato, premendo rapidamente due volte il tasto home.
    \nPer fare questo \u00e8 necessario impostare il nostro UIViewController come primo risponditore implementando il seguente metodo:<\/p>\n
    \r\n\/* required for remote control *\/\r\n- (BOOL)canBecomeFirstResponder {\r\nreturn YES;\r\n}\r\n<\/pre>\n
    A questo punto, la nostra classe UIViewController \u00e8 in grado di rispondere agli eventi inviati dal controllore multimediale remoto. Il metodo da implementare per reagire correttamente a questi eventi \u00e8 remoteControlReceivedWithEvent:. Ci baster\u00e0 controllare l’oggetto UIEvent passato come parametro e reagire di conseguenza:<\/p>\n
    \r\n#pragma mark -\r\n#pragma mark Remote Control Event Handling\r\n\r\n- (void)remoteControlReceivedWithEvent: (UIEvent *) receivedEvent {\r\n    if (receivedEvent.type == UIEventTypeRemoteControl) {\r\n        NSLog(@\"subtype: %d\", receivedEvent.subtype);\r\n        switch (receivedEvent.subtype) {\r\n            case UIEventSubtypeRemoteControlPlay:\r\n                [streamPlayer startPlay];\r\n                break;\r\n            case UIEventSubtypeRemoteControlPause:\r\n                [streamPlayer startPlay];\r\n                break;\r\n            case UIEventSubtypeRemoteControlStop:\r\n                [streamPlayer startPlay];\r\n                break;\r\n            case UIEventSubtypeRemoteControlTogglePlayPause:\r\n                [streamPlayer startPlay];\r\n                break;\r\n            default:\r\n            break;\r\n        }\r\n    }\r\n}\r\n<\/pre>\n
    Github: Dove trovate l’esempio<\/h4>\n
    L’esempio completo, citato in quest’articolo \u00e8 disponibile su github all’indirizzo: https:\/\/github.com\/valvoline\/CPStreamPlayer<\/a><\/p>\n
    Vi \u00e8 piaciuto l’articolo? Ringraziate l’autore Costantino Pistagna scaricando la sua applicazione “Strips<\/a>” (GRATIS in App Store) e VOTATELA<\/a> come migliore applicazione italiana.<\/strong><\/center><\/p>\n

    \n    \"Strips-iPhone\"<\/a>
    \n<\/center><\/p>\n","protected":false},"excerpt":{"rendered":"
    Se si potesse stilare una classifica dei meccanismi meno conosciuti di Cocoa, il Key-Value Observing pattern o…<\/p>\n","protected":false},"author":476,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[1105,1050,1103,1101,1104,1102,934,835],"class_list":["post-8957","post","type-post","status-publish","format-standard","hentry","category-tutorial-pratici","tag-avplayer","tag-design-pattern-ios","tag-key-value-coding","tag-key-value-observing","tag-kvc","tag-kvo-ios","tag-model-view-controller","tag-nsnotificationcenter"],"acf":[],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/posts\/8957","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/users\/476"}],"replies":[{"embeddable":true,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/comments?post=8957"}],"version-history":[{"count":16,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/posts\/8957\/revisions"}],"predecessor-version":[{"id":9000,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/posts\/8957\/revisions\/9000"}],"wp:attachment":[{"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/media?parent=8957"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/categories?post=8957"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/tags?post=8957"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}