Personalmente era la prima volta che avevo la necessità di fare in modo che le immagini conservassero questi dati anche quando caricate tramite delle API. Pensavo che iOS fornisse dei metodi standard per queste operazioni, invece la questione si è rivelata più particolare del previsto.

In questo articolo troverete l’implementazione iniziale che utilizzavo, e le nuove modifiche che ho apportato per riuscire a risolvere il problema.

Situazione attuale

Gestisco da diverso tempo (probabilmente dal 2010) il progetto in questione. Una delle varie funzionalità è la possibilità dell’utente di allegare delle foto, che vengono caricate su un backend tramite un servizio apposito. Di recente, tuttavia, è emersa la necessità che le immagini caricate mantengano i dati EXIF associati, in particolare quelli relativi alla geolocalizzazione.

Facendo alcune prove, ci siamo accorti che le immagini caricate dall’app iOS erano prive di tali dati, quindi mi sono messo ad indagare la cusa del problema.

L’implementazione esistente è composta principalmente da tre fasi:

1. selezione delle immagini, utilizzando il picker nativo UIImagePickerController
2. salvataggio in locale (nella directory Cache) delle immagini selezionate, operazione propedeutica allo step 3
3. upload delle immagini tramite URLSession.uploadTask

Dopo alcune verifiche, era chiaro che il problema fosse al punto 2: le immagini salvate temporaneamente in locale erano già prive dei dati EXIF.

The old way: jpegData(compressionQuality:)

Il codice esistente salvava le immagini ricavate dal rullino utilizzando il metodo jpegData(compressionQuality:) che UIImage mette a disposizione. Partendo dal PHAsset, veniva estratta l’immagine e poi salvata in locale, in modo da avere un file da trasformare poi in un oggetto di tipo Data.

Questo è un esempio (minimale) di come venivano salvate le immagini:

private func savePhotoWithoutExif(
    info: [UIImagePickerController.InfoKey : Any],
    localUrl: URL
) throws {
    guard let image = info[.originalImage] as? UIImage else {
        throw PhotoError.missingImageData
    }
        
    guard let data = image.jpegData(compressionQuality: 1.0) else {
        throw PhotoError.invalidImage
    }
        
    do {
        try data.write(to: localUrl)
    } catch {
        throw PhotoError.saveFailed
    }
}

Se andiamo ad analizzare l’immagine che salva questo metodo, ci accorgeremo che i dati EXIF non sono più presenti (in particolare le coordinate GPS):

Per analizzare le immagini, ho utilizzato il Simulatore di iOS e stampato in console il percorso completo del file generato. In questo modo ho potuto navigarci tramite il Finder ed aprire il file con Anteprima, che permette di visualizzare tutti gli EXIF contenuti nel file.

The new way: CIContext().writeJPEGRepresentation

Mi sono messo alla ricerca di una soluzione che permettesse di salvare una copia dell’immagine in locale, senza però perdere i dati EXIF. Dopo qualche ricerca e un po’ di studio della documentazione, ho trovato una soluzione che si basa sull’utilizzo di CIContext. In sostanza, si tratta di renderizzare ed esportare l’immagine in formato jpeg, utilizzando il metodo writeJPEGRepresentation(of:to:colorSpace:) presente in CIContext. In questo modo, i dati EXIF vengono mantenuti.

Il codice è leggermente più complesso rispetto al precedente, qui ve lo propongo ripulito di altri controlli che ho aggiunto nella mia implementazione:

// create request to get all asset metadata
let options = PHContentEditingInputRequestOptions()
// download from iCloud if necessary
options.isNetworkAccessAllowed = true
asset.requestContentEditingInput(with: options) { (contentEditingInput: PHContentEditingInput?, _) -> Void in
    guard let contentEditingInput else {
        print("[ERROR] Unable to get PHContentEditingInput")
        return
    }
    guard 
        let imageUrl = contentEditingInput.fullSizeImageURL,
	let fullImage = CIImage(contentsOf: imageUrl, options: [ .applyOrientationProperty: true ]),
	let colorSpace = fullImage.colorSpace else {
	   print("[ERROR] Unable to create required parameters")
           return
	}
             
    do {
        try CIContext().writeJPEGRepresentation(of: fullImage,
                                                to: localUrl,
                                                colorSpace: colorSpace)
    } catch {
        print("[ERROR] Unable to write image (\(error.localizedDescription))")
    }
}

Si tratta, in sostanza, di ricavare tutti i metadati associati al PHAsset che stiamo gestendo, per poi renderizzare l’immagine tramite il metodo writeJPEGRepresentation.

Se andiamo a comparare i dati EXIF della foto originale e di quella salvata, vedremo in questo caso che sono identici, non abbiamo perso nessuna informazione:

Conclusioni e progetto

La soluzione che vi ho presentato è molto ridotta rispetto a quella reale che ho implementato. Non sono supportati, ad esempio, i vari formati che potete trovare in un PHAsset (ad esempio le live photos). L’obbiettivo era focalizzarmi sul solo punto che effettivamente vi permette di salvare delle immagini conservando i metadati EXIF.

Ho creato un repository su GitHub con un semplice progetto d’esempio, con cui potete verificare le due diverse implementazioni. Per qualsiasi domanda, scrivetemi nei commenti o su Mastodon.

Per i più curiosi, questa è l’immagine che ho utilizzato per le prove di questo articolo, scattata a Tokyo il 26/01/2020 (sigh).

Ciao!

The post Come salvare un’immagine in Swift preservando i dati EXIF first appeared on bubidevs.

C’era però un grande assente: il terminale. Come ogni sviluppatore che si rispetti, il terminale è un fedele compagno di lavoro, che personalmente mi trovo ad utilizzare per parecchio tempo durante la giornata. Questa è, attualmente, la configurazione del mio terminale:

In questo articolo vi parlerò di cosa utilizzo, come l’ho personalizzato e come l’ho reso aderente alle mie necessità.

Situazione iniziale

Di default, macOS mette a disposizione un classico terminale, che funziona egregiamente ma è abbastanza spoglio:

Da qualche anno zsh è la shell predefinita, e questa è una buona notizia. Come vedremo, infatti, c’è un ottimo framework che permette di estendere le funzionalità e personalizzare molti aspetti della shell.

iTerm2

Come prima cosa, ho sostituito il Terminale con iTerm2. Si tratta di un sostituto per il terminale di macOS, che offre molte funzionalità in più e una serie quasi infinita di possibili personalizzazioni.

In particolare, ci sono due funzionalità di cui non posso più fare a meno: lo split verticale (e orizzontale) di più sessioni e la ricerca testuale all’interno di una sessione.

iTerm2 è gratuito e si scarica direttamente dal sito degli sviluppatori. Da qui possiamo iniziare a rendere il terminale sempre migliore.

Oh-my-zsh

Dopo aver scaricato ed installato iTerm2, il passo successivo è installare Oh My Zsh. Questa è la descrizione che viene data dagli sviluppatori:

Oh My Zsh è un delizioso framework open source guidato dalla community per la gestione della configurazione di Zsh.

In sostanza, Oh My Zsh mette a disposizione una serie di temi e plugin sviluppati dalla community, in modo da potervi creare un ambiente cucito sulle vostre esigenze.

L’installazione è molto semplice, si deve eseguire un comando che potete trovare direttamente sulla home del progetto.

Oh My Zsh non è un’esclusiva di macOS o di iTerm2: potete installarlo in qualsiasi sistema operativo, a patto di utilizzare una shell zsh (e perchè non dovreste?).

Tema, plugin e configurazioni

Abbiamo quindi installato iTerm2 e Oh My Zsh, siamo pronti per creare l’assetto più indicato alle nostre necessità. Vi mostro quali sono le personalizzazioni e le configurazioi che ho impostato nel mio ambiente, di cui sono abbastanza soddisfatto.

Tema

Partiamo dal tema. Dopo averne valutati diversi, ho ristretto il cerchio a tre candidati:

• Pure
   Minimal e di bel design
   Poche possibilità di configurazioni
• Powerlevel10k
   Molte possibilità di personalizzazioni
  Aspetto un po’ troppo “pieno”, ho riscontrato anche qualche problema con alcune funzionalità (es. la visualizzazione della versione di Ruby)
• Spaceship
   Design minimale
   Ampia possibilità di configurazioni

And the winner is… Spaceship!

L’installazione non è complessa, ma assicuratevi di seguire tutti i passi della documentazione, per fare in modo che tutto funzioni correttamente.

Miglioramenti al tema

Per ottenere il mio stesso design, ci sono alcune modifiche da fare:

• installare il font Fura Mono Regular, che vi permette di avere anche le icone usate, ad esempio, per i rami di Git (repository GitHub)
• installare il preset colori Snazzy per iTerm2 (repository GitHub)
• impostare in iTerm:
  • tema finestra minimale (Appearance -> General -> Theme -> Minimal)
  • cursore come lampeggiante (Profiles → Text → Cursor: Box e Blinking)

Ed ecco il risultato finale:

Configurazione del prompt

Il tema Spaceship offre molte possibilità di personalizzazione. Per farlo, è sufficiente agire sul file di configurazione posto in .config/spaceship.conf. Questa è la mia configurazione:

# Prompt configuration
SPACESHIP_PROMPT_ORDER=(
  time
  user
  host
  dir
  git
  venv
  line_sep
  char
)

# Char
SPACESHIP_CHAR_SYMBOL=">" # replace default ➜ character
SPACESHIP_CHAR_SUFFIX=" " # add a space after the char symbol

# Dir
SPACESHIP_DIR_PREFIX='' # disable directory prefix, cause it's not the first section
SPACESHIP_DIR_TRUNC='1' # show only last directory

SPACESHIP_PROMPT_ORDER definisce gli elementi che vengono visualizzati nel prompt:

Con SPACESHIP_CHAR_SYMBOL ho modificato il simbolo che viene mostrato, con il simbolo “maggiore” che non mi dispiace.

SPACESHIP_DIR_PREFIX permettono, infine, di decidere quante e quali parte del path mostrare. Personalmente mi piace vedere solo la folder in cui sono, non ho la necessità di vedere il path completo.

Plugin Oh My Zsh

All’interno del file .zshrc è possibile specificare quali plugin di Oh My Zsh vogliamo abilitare.

plugins=(
   wd
   xcode
   vscode
)

• xcode: fornisce alcune utility molto comode per lavorare con Xcode e lo sviluppo iOS in generale
• vscode: fornisce alcuni alias molto utili per lavorare con VSCode (ad esempio per aprire la folder corrente o uno specifico file direttamente nell’editor)
• wd: è il mio plugin preferito. Consente di creare dello scorciatoie e poi navigarci velocemente. Ad esempio, se ci capita di andare spesso nella folder ~/Work/repos/customer_a/project_01, possiamo definire una scorciatoia project_01 e richiamarla velocemente con wd project_01, navigando così direttamente dentro la relativa folder. Personalmente non ne posso più fare a meno.

Alias zshrc

Ho definito alcuni alias sempre nel file .zshrc, in questo caso il commento penso sia chiaro per tutti i comandi:

# open Sublime Merge for current directory
alias sm="smerge ." 
# needed because HEAD^ doesn't work with zsh
alias grh="git reset HEAD~1" 
# shortcut for forced git push
alias gpf="git push -f"
# be sure to always use Bat instead of standard cat
alias cat=bat

Conclusioni

Sono molto soddisfatto del setup che sono riuscito a creare per il terminale, mi ci trovo molto bene.

Ci sono alcune aggiunte che sto provando e che sto ancora valutando. Una di queste, ad esempio, è bat, una versione evoluta del classico cat, che offre funzionalità quali i numeri di riga o la formattazione della sintassi.

Spero di avervi dato qualche spunto, se c’è qualcosa che volete consigliarmi, scrivetemelo nei commenti o parliamone su Mastodon!

The post Il mio setup 2023 – Terminale con iTerm2 e Oh My Zsh first appeared on bubidevs.

Non è stata un’operazione particolarmente lunga, in una giornata di lavoro sono tornato ad avere tutto configurato. Avendo la maggior parte dei miei dati in cloud, questo tipo di operazioni si è semplificato di molto.

In questo articolo ho raccolto sia le configurazioni che ho fatto a macOS, sia le app che ho installato e che utilizzo (quasi) giornalmente. Dedicherò un altro articolo, invece, alla configurazione del terminale.

macOS

Ci sono un serie di impostazioni che sono abituato ad avere in macOS e, nel caso di ripristino o di nuovo Mac, vado subito ad impostare. Eccovene alcune, suddivise in base alle nuove categorie introdotte in Ventura

Effetto genio

Abilita l’effetto ingrandimento quando si passa con il cursore sopra le icone nel dock.

Tap sul trackpad

Il singolo tap sul trackpad del MacBook, viene considerato come il click del mouse. Personalmente lo preferisco rispetto al “clic” standard che deve essere eseguito sul trackpad.

Non riorganizzare gli spazi

Di default, macOS riorganizza gli spazi in base all’ultimo utilizzo. Questa cosa mi manda in confusione, preferisco che siano fissi in modo da poter organizzarli in base alle app e al mio flusso di lavoro.

Touch Bar

Non sono l’unico a pensare che la Touch Bar sia inutile. Non utilizzo mai le azioni che mi propone, quindi ho attivato questa opzione per fare in modo che mostri sempre i controlli che utilizzo di più, come la gestione della luminosità e del volume.

Dock

Sul dock non mi interessa avere le applicazioni recenti che ho aperto: se le utilizzo spesso, hanno già un posto sul dock, altrimenti le richiamo quando mi servono. Less is more.

Sempre sul dock, ho da sempre avuto l’abitudine di avere queste tre folder: Applicazioni, Documenti e Download. Tutte, inoltre, sono configurate per essere mostrate come cartelle e la visualizzazione è Griglia.

Apps

Vi propongo di seguito l’elenco delle app che ho attualmente installato sul mio Mac. Ho escluso quelle presenti di default nel sistema operativo e alcune di cui probabilmente non vi interessa nulla (vero orribile client di NowTV?)

Utility

• AirBuddy: utility per gestire al meglio le AirPods connesse al Mac. Tra le varie cose, permette di avere un popup come quello che appare su iOS quando si apre il case delle AirPods in prossimità del Mac.

• Alfred: sostituto di Spotlight, con i superpower. Ho diversi Workflow che utilizzo giornalmente e mi semplificano alcune attività.

• Bartender 4: permette di gestire al meglio la menu bar, decidendo, tra le altre cose, quali elementi visualizzare e quali nascondere.

• CleanMyMac X: app per fare pulizia nel Mac, cancellando file non più necessari o per scovare cartelle “pesanti” che ci eravamo dimenticati.

• CloudMounter: permette di montare gli account di cloud storage, per poterli usare come se fossero dischi collegati al Mac.

• Magnet: permette di gestire il posizionamento delle finestre. Funzione su cui macOS è indietro anni luce rispetto a Windows.

• Shortery: permette di definire dei trigger per i Comandi Rapidi. Ad esempio, è possibile eseguire in automatico degli shortcuts quando si connette una periferica o ad un determinato orario.

• Shottr: tool per effettuare screenshot ed editarli. L’editor integrato offre alcune funzionalità fantastiche: la possibilità di “blurrare” del testo e un righello per misurare la distanza tra elementi. Provatela.

• The Unarchiver: permette di estrarre qualsiasi archivio, esempio rar, zip o sit.

• Logi Options+: utility necessaria se utilizzate dispositivi Logitech. Permette di modificarne le impostazioni e adattarli alle vostre esigenze.

Produttività

• 1Password: password manager, il migliore.

• Arc: browser moderno e alternativo, che fornisce alcune funzionalità davvero interessanti (es. split di due tab). Se volete un invito, scrivetemi nei commenti.

• BusyCal: app per la gestione dei calendari. Sono fuggito da Fantastical perchè non ho voglia di pagare un abbonamento anche per l’app del calendario. BusyCal è davvero ottima e si trova spesso in sconto.

• Cyberduck: client per connettersi in FTP a cartelle e server remoti (e non solo).

• Mimestream: client per Gmail, nativo e leggero. È ancora in fase beta ma funziona molto bene.

• Notion: app dell’omonimo servizio. Se ancora non la usate, recuperate subito.

• Obsidian: chiamarlo text editor è limitativo, ma in sostanza è quello che fa. Non ne sono un grande estimatore, lo utilizzo solo per scriverci le bozze dei post giusto per provarlo. Al momento preferisco Notion come idea.

• Pixelmator Pro: editor di immagini, più semplice e più economico di Photoshop, ma sempre al top come funzionalità e novità.

• Slack: client per la migliore piattaforma di messaggistica per team

• Sublime Text: popolare editor di testo e codice. Lo utilizzo molto per appuntarmi o copiare del testo al volo, trovo fantastico poter chiudere la finestra, riaprirla e trovarmi ancora li quello che avevo digitato.

• iTerm: sostituto per il classico terminale, offre una serie infinita di impostazioni e possibilità di personalizzazione.

Developer

• Android Studio: ambiente di sviluppo per Android (e non solo).

• Docker Desktop: app per il celebre gestore di container e immagini Docker.

• Fork: client Git nativo per macOS. Davvero ben fatto, pulito e comodissima la possibilità poter aprire più tab. Costa circa 50$, potete prima valutarlo con la versione di prova che non ha scadenza.

• Kaleidoscope: app storica per effettuare la comparazione tra files. Fondamentale se bisogna effettuare il merge di file che non sono sotto versionamento.

• Postman: originariamente client per effettuare chiamate ad API. Io lo uso principalmente per questo, ma oggi ha davvero un’infinità di altre funzioni.

• Sublime Merge: è un client Git, ma io lo utilizzo solamente per la risoluzione dei conflitti durante un merge/rebase. È secondo me il migliore in circolazione.

• Visual Studio Code: forse il più famoso editor di codice degli ultimi anni. Lo utilizzo quando ho file singoli o per progetti Python/web.

• Visual Studio: forse il peggior editor di codice per macOS. Necessario per sviluppare in C# su macOS.

• Xcode: l’unico IDE possibile per scrivere app per il mondo Apple.

Bonus: i wallpapers

Come sfondi del desktop ho trovato questa fantastica collezione chiamata Aquex: riprendono lo stile dello sfondo di default di Mac OS X 10.0 (che ho recentemente provato), con colori però che riprendono le successive versioni di macOS.

Che dire, sono semplicemente stupendi, li potete acquistare direttamente sul sito per soli 3 $.

Conclusioni

Sono soddisfatto del mio setup attuale, ormai alcune app le utilizzo da diversi anni e non riuscirei più a farne a meno. Ci sono alcune alternative che sto valutando, ma che non mi hanno ancora convinto per uno switch:

• Raycast: alternativa di Alfred, sembra essere molto potente, ma no ho ancora trovato il giusto feeling
• Cron: alternativa a BusyCal, è molto ben fatta ma al momento supporta solo gli account Google, mentre il mio calendario personale è su iCloud, per ora è una limitazione bloccante

Per i più smanettoni, prossimamente pubblicherò un articolo con tutte le configurazioni che ho fatto ad iTerm, il tema e i plugin che utilizzo per configurare zsh.

The post Il mio setup 2023 – macOS e app first appeared on bubidevs.

Sia chiaro, ora non ho un Mac che posso usare tutti i giorni, e tornerà sicuramente sullo scaffale passata questa euforia, ma è stato divertente metterci mano e riassaporare un po’ la possibilità di smontare il computer e metterci mano, cosa che con i Mac di oggi è impossibile.

Situazione iniziale

L’iMac è il modello Bondi Blue del 1998 (revisione A), con sistema operativo Mac OS 9.2.2. Le caratteristiche tecniche non sono delle migliori:

• processore PowerPC a 233 MHz
• 160 MB di RAM (penso fosse già stata aumentata dal precedente proprietario)
• 4 GB di hard disk
• CD-ROM 24x
• Ethernet integrata

L’idea è semplice: aumentare la RAM, cambiare l’hard disk e aggiornare il computer a Mac OS X, magari provando le varie versioni fino alla 10.2. Ufficialmente l’ultima versione supportata è la 10.3, ma sui vari forum viene sconsigliata perché rende la macchina quasi inutilizzabile.

Aggiornamento hardware

Su eBay ho trovato un banco di RAM da 128 MB, da un venditore tedesco a 6,89 €. Bisogna cercare con attenzione, l’unica tipologia supportata è la PC66 SDRAM, ma non è nemmeno troppo difficile trovare ancora dei banchi originali o comunque compatibili.

Per l’hard disk, invece, ho recuperato un disco da 20 GB che non utilizzato, un normale PATA da 3,5″, come quelli che si montavano nei PC fissi dei primi anni 2000 (quanto mi sento vecchio).

Per installarli, bisogna smontare lo sportello inferiore del Mac, scollegare i cavi e rimuovere la scheda logica:

Da qui si accede allo scompartimento che contiene la RAM e il processore (nascosto dal dissipatore):

L’hard disk, invece, è leggermente più ostico, perché si trova sotto il lettore CD. Come sempre, la cosa migliore è seguire la guida di iFixit, che spiega i vari passaggi da effettuare.

Fatto! Rimontiamo tutto, colleghiamo i cavi e scopriamo se funziona!

Batteria e reset CUDA

Poteva andare tutto liscio? Ovviamente no. Al primo riavvio l’iMac è partito correttamente, e un’icona indicava la mancanza dell’hard disk:

Tutto ok, l’hard disk era da formattare quindi nessun problema. Al successivo riavvio, però, l’iMac non voleva saperne di ripartire. Classico “gong” iniziale ma schermo nero, nessun segnale di vita.

Smonto tutto nuovamente e provo un reset CUDA. Si tratta di un bottoncino presente sulla scheda madre, che effettua una sorta di reset “profondo” e che tendenzialmente risolve questi problemi. Premo il bottone una sola volta, come si trova nei manuali, dovrebbe bastare per eseguire il reset. Rimonto nuovamente l’iMac, ma ancora nulla, l’iMac non vuole proprio ripartire.

Provo quindi una serie infinita di reset, più o meno strani che trovo in rete. Nessun risultato, il Mac non si avvia. Provo a rimettere il vecchio hard disk e togliere il banco nuovo di RAM, ma la situazione non cambia. Ad un certo punto su un forum trovo un utente che scrive:

I have to press the CUDA button for at least 30 seconds to boot up my Mac

GENIO! Provo a tenere premuto per 30 secondi questo dannatissimo bottone e.. boom! L’iMac si accede nuovamente! Finalmente!

Mission impossible: masterizzare dei CD nel 2023

Avevo già scaricato le immagini di Mac OS X dal fantastico sito MacinotshRepository, che contiene una serie infinita di software per i computer vintage di Apple.

Pensavo che masterizzare le immagini sarebbe stato veloce, ma ho sottostimato questo aspetto. Masterizzare dei CD nel 2023 non è per nulla scontato. La prima impresa è stata recuperare dei CD vergini: ne avevo recuperati 3, pensando fossero sufficienti. Ma li ho buttati con le prime prove di masterizzazione. Ho recuperato poi una mezza “campana”, circa 20 CD, che fortunatamente sono bastati.

L’unico computer con un masterizzatore che avevo in casa era il mio MacBook bianco che ho recentemente rimesso a nuovo. Ho provato quindi a masterizzare le immagini da li, ma i CD non venivano riconosciuti dal Mac. All’avvio, infatti, il Mac tentava di partire da CD ma non riusciva, restava in uno stato non ben definito.

Anche qui spulciando sui vari forum consigliavano di masterizzare le immagini con Mac OS, perché a quanto pare altri sistemi operativi saltano qualche file nascosto. Ho dovuto quindi collegare il vecchio hard disk con macOS al MacBook e masterizzarli dal caro vecchio “Utility Disco”, che non ha fallito l’obbiettivo.

Mac OS X 10.0

“Disco dentro, C a martello, scatenate l’installazione!” (semicit)

Anche qui, primo inghippo. L’installer non mi permetteva di selezionare il disco fisso, nonostante lo avessi inizializzato da Utility Disk. Dopo varie ricerche, ho scoperto che la partizione in cui installare il sistema operativo deve essere al massimo di 8 GB. Ho quindi partizionato in due il disco, e finalmente ho potuto scegliere la destinazione e proseguire.

L’installazione dura circa 30/40 minuti, con quel piacevole rumore del CD che gira, un suono che avevo rimosso.

Ed ecco finalmente Mac OS X 10.0:

La prima versione di Mac OS X non è sicuramente delle migliori, il sistema è abbastanza lento e qualche applicazione mi è crashata in pochi minuti di utilizzo. Però il design è davvero figo, alcuni degli elementi e parte dell’interfaccia è praticamente la stessa che c’è oggi in macOS. La mela colorata nella barra dei menu è qualcosa che dovrebbero reintrodurre!

Si avete visto bene, come browser di default era installato Internet Explorer 5. Purtroppo navigare con quei browser oggi è impossibile, la cifratura dei siti HTTPS moderni non è supportata. Ci sono dei meccanismi per risolvere il problema, ma non ho ancora avuto modo di provarci.

Piccola nota, gli screenshot ho dovuto realizzarli con il tool integrato nell’OS, perché la classica combinazione “Cmd + Shift + 3” non funzionava, a quanto pare è stata implementata successivamente.

Mac OS X 10.1

Ho installato poi Mac OS X 10.1, la procedura di installazione è praticamente la stessa, mentre il sistema operativo sembra più stabile e scattante. In questa versione sono stati introdotti iTunes e iMovie:

PS: qui la combinazione per fare gli screenshot era funzionante.

Mac OS X 10.2

Prima piccola novità avviando il CD di Mac OS X 10.2: invece dell’icona dell’Happy Mac, appare il logo grigio Apple. La procedura di installazione è del tutto simile alle versioni precedenti. In questo caso sono 2 i CD da utilizzare e la procedura è durata circa 1 ora e mezza.

Il sistema è sicuramente più rifinito, non ci sono più quei piccoli errori e imperfezioni delle versioni precedenti (ad esempio alcune parti non localizzate in italiano), anche se l’iMac sembra faticare un po’ di più rispetto alle precedenti versioni.

Spuntano anche alcune vecchie conoscenze: iChat, Rubrica e iPhoto.

Conclusioni

Non nego che arrivare in fondo è stata un’avventura, soprattutto quando il Mac non si avviava ho pensato di richiudere tutto e riporlo nello scaffale. Ma noi ingegneri siamo teste dure, e farci desistere da qualcosa è davvero difficile.

Prossimamente voglio cercare di avere un browser funzionante, per poter visitare bubidevs dall’iMac G3. Ci sono dei proxy server che permettono di navigare con vecchi browser non più supportati. Uno dei più consigliati è WebOne, devo trovare il tempo di configurarlo.

Vorrei anche riuscire a fare il dual boot tra Mac OS X e Mac OS 9, è una procedura supportata, quindi non dovrebbe essere complicato.

In definitiva, avrei potuto impiegare meglio il mio tempo? Si. È stato utile? No. Mi sono divertito? Un sacco. Quindi va bene così, ora posso guardarmi uno dei più bei Mac di sempre ed essere soddisfatto di averlo rimesso in funzione.

The post Ho rimesso in funzione il mio iMac G3 Bondi Blue first appeared on bubidevs.

Era inutilizzato da parecchio tempo, in particolare perché la retroilluminazione non funzionava più, quindi era necessario collegarlo sempre ad un monitor esterno.

Mi sono chiesto, “possibile non riuscire a dargli una seconda (o forse terza) vita?”. Spoiler: sì, è stato possibile, e questo è il risultato:

Questo post farà da diario alle configurazioni e alle sostituzioni fatte e che (spero) di poter fare in futuro.

Let’s fix the hardware!

Dopo averlo acceso e provato per qualche minuto, ho individuato alcune cose da sistemare:

• la retroilluminazione: punto fondamentale, un portatile con lo schermo non funzionante è un paradosso
• l’hard disk: montare un SSD può dare un boost alle prestazioni?
• la batteria: è esausta, aspetto che compromette anche le prestazioni

Quel maledetto cavo dell’inverter

Il primo problema da risolvere era la retroilluminazione non più funzionante. Problema diffuso per questo modello, a cui però mi ero rassegnato utilizzando un monitor esterno.
Spulciando in rete, invece, ho scoperto che il problema è tipicamente dovuto ad un maledetto cavetto che si danneggia e causa il malfunzionamento.

Dove cercare il ricambio? Ma su AliExpress, che domande: 5,62 € (spedizioni incluse) e il nuovo cavo dell’inverter è arrivato sulla mia scrivania.

La procedura di sostituzione non è stata delle più semplici, ho dovuto smontare praticamente tutto il computer per accedere al cavo e sostituirlo. Fortunatamente iFixit ha una guida dettagliata sulla procedura da seguire, che mi ha salvato da alcuni errori che avrei sicuramente commesso.

Piccola nota, non è necessario staccare completamente il display come nella guida, ma basta appoggiarlo ed avrete tranquillamente accesso al cavo da sostituire, risparmiandovi di dover scollegare tutti i cavi nella parte centrale.

SSD

Il secondo step è stato sostituire l’HDD da 5.400 rpm con un fiammante SSD da 128 GB. Fiammante si fa per dire, anche qui AliExpress ha aiutato a contenere il budget: 13,39 € e disco arrivato in meno di 10gg.

La sostituzione è banale, basta togliere la batteria, smontare il profilo metallico e si accede allo slot dell’hard disk. Lascio comunque il link alla guida di iFixit.

Attenzione: questo modello di MacBook ha un collegamento SATA da 1,5 GB, mentre i moderni SSD hanno una velocità di 6 GB. Solitamente non è un problema, ma alcuni modelli potrebbero non funzionare correttamente. Almeno, così ho letto su diversi forum, io personalmente non ho avuto problemi con il modello che ho acquistato.

Batteria (e performance)

Su Amazon ho acquistato una nuova batteria (28,99 € la spesa), non proprio uguale a quella originale ma fa il suo lavoro.

Ho sempre saputo che usare il MacBook senza batteria (o con una esausta, come nel mio caso) riduceva le prestazioni del Mac, ma non avevo mai avuto modo di fare una verifica. Ho preso l’occasione per fare dei test con Geekbench 5 e i risultati sono stati quasi sorprendenti:

Il punteggio in Single-core è passato da 187 a 329, mentre quello in Multi-core da 366 a 484! Un incremento davvero notevole!

Piccola curiosità, questa è invece una comparazione tra il MacBook e la mia attuale accoppiata iPhone 13 / MacBook Pro M1:

Potete trovare tutti i risultati dei benchmark sul mio profilo di Geekbench.

Let’s fix the software!

Dopo aver sistemato la ferraglia, è giunto il momento di dare un nuovo software al MacBook. Non volevo installare macOS, l’ultima versione compatibile era Lion (10.7.5), e provare qualche hack per installare versioni successive non mi andava.

Ho cercato quindi una distro Linux che non fosse troppo pesante ma anche decente graficamente, e ho scoperto Pop!_OS, di cui si parla bene. Quindi, why not?

Installazione di Pop!_OS

L’installazione di Pop!_OS è quella di una qualsiasi distro Linux:

1. download dell’ultima immagine disponibile (22.04 al momento in cu scrivo) dal sito ufficiale
2. tramite BalenaEtcher, creazione di una chiavetta USB da cui eseguire il boot
3. avviare il Mac e premere Alt, apparirà così la possibilità di avviare da USB e non dall’HDD (che nel mio caso era comunque vuoto)

La procedura di avvio della live distro non è delle più veloci, ma tempo 1 minuti e ci si trova nel desktop di Pop!_OS, con la possibilità di completare l’installazione.

Et voilà!

Abilitazione scheda di rete

Poteva funzionare tutto subito? No, altrimenti non sarebbe una distro Linux ma si chiamerebbe macOS

Il primo problema da risolvere è la scheda WiFi non riconosciuta. Per questo specifico modello si tratta di una Broadcom 4321. È bastata una veloce ricerca per trovare il post giusto con la procedura da eseguire via terminale:

sudo apt-get update
sudo apt-get --reinstall install bcmwl-kernel-source

sudo modprobe -r b43 ssb wl brcmfmac brcmsmac bcma
sudo modprobe wl

Ovviamente è necessario essere collegati via cavo per poter installare i pacchetti necessari. Dopo un immancabile sudo reboot, ecco la scheda di rete funzionante!

Abilitazione iSight

Una volta connessi via WiFi, ho pensato “chissà se funziona la webcam”. Beh potete immaginare la risposta

La ricerca qui è stata più veloce: ho trovato un post del 2010 con la procedura da effettuare. La riporto di seguito, perchè “2 copies is megl che one”.

STEP 1
Recuperare il file AppleUSBVideoSupport da un’installazione di Mac OSX (10.4 o 10.5). Il file si in questo percorso:

/System/Library/Extensions/IOUSBFamily.kext/Contents/PlugIns/AppleUSBVideoSupport.kext/Contents/MacOS/AppleUSBVideoSupport

Ho impiegato un po’ per recuperare il file (per fortuna avevo il vecchio HD con l’installazione di MacOS X), quindi lo allego qui per backup.

STEP 2
Copiare il file AppleUSBVideoSupport in una folder dell’installazione Linux (supponiamo sia in ~/Downloads)

STEP 3
Aprire un terminale e installare iSight Firmware Tools:

sudo apt-get update
sudo apt-get install isight-firmware-tools

STEP 4
L’installer chiederà di selezionare il file AppleUSBVideoSupport, specificate il percorso completo (nel mio caso, /home/andrea/Downloads/AppleUSBVideoSupport)

STEP 5
Effettuate un riavvio e godetevi la vostra fantastica iSight alla risoluzione di 640×480!

Prossimi step

Il mio MacBook è tornato operativo e al momento è fisso sulla mia scrivania, perchè mi piace averlo e riprodurci della musica con una qualità audio abbastanza scadente, ma ha il suo fascino.

Ho qualcosa in mente per migliorarlo ulteriormente,

• batteria: l’ho ordinata su Amazon (28,99 €), appena arriva aggiornerò l’articolo con un benchmark di confronto delle prestazioni
• frame nuovo: purtroppo la cornice del display è un po’ rovinata e si è anche rotta durante lo smontaggio. Sto rastrellando eBay alla ricerca di un frame nuovo, ma al momento senza successo
• tastiera: mi piacerebbe provare a montare la tastiera della variante nera del MacBook, o ancora meglio trovare una tastiera non originale ma retroilluminata. Qualcuno l’aveva già fatto (qui e qui), definendolo MacBook “oreo”.

Terrò aggiornato il post con eventuali modifiche future, chissà se questo Pop!_OS sopravviverà o tornerò al caro vecchio OS X!

Aggiornamento 08/12/2022: aggiunto il paragrafo Batteria, con i relativi benchmark.

The post Storia di un MacBook late 2007, di Pop!_OS e di un cavetto first appeared on bubidevs.

C’è una piccola insidia, tuttavia, nella gestione della memoria che può portare ad avere dei retain cycle all’interno della classe/controller in cui vi trovate a definire il timer.

La documentazione di Apple definisce così la classe Timer (NSTimer per i nostalgici):

Timers work in conjunction with run loops. Run loops maintain strong references to their timers, so you don’t have to maintain your own strong reference to a timer after you have added it to a run loop.

Un timer in automatico inserito nel run loop in cui viene istanziato (generalmente il main thread), questo però comporta un’insidia non da poco. L’ownership non è (solo) della classe in cui andate a definirlo, ma bisogna agire manualmente per invalidarlo e annullare il suo riferimento.

Proviamo a spiegare il tutto con un semplice esempio.

Creiamo un timer ripetuto

Supponiamo di avere un semplicissimo UIViewController che istanzia un timer:

import UIKit

class SampleViewController: UIViewController {

    private var timer: Timer?

    // MARK: - Init

    convenience init() {
        self.init(nibName: nil, bundle: nil)
        view.backgroundColor = .white
    }

    deinit {
        print("[SampleViewController] deinit called")
    }

    // MARK: - View Lifecycle

    override func viewDidLoad() {
        super.viewDidLoad()

        timer = Timer.scheduledTimer(timeInterval: 1.0, target: self, selector: #selector(timerFired(_:)), userInfo: nil, repeats: true)
    }

    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)

        timer = nil
    }

    // MARK: - Private

    @objc private func timerFired(_ sender: Timer) {
        print("[SampleViewController] timer fired")
    }
}

Da un altro controller istanziamo SampleViewController e lo dismettiamo con un semplice drag verso il basso.

let controller = SampleViewController()
present(controller, animated: true)

Retain cycle in agguato

Ci sembrerebbe di aver fatto tutto in maniera corretta, ma guardando la console notiamo che il deinit non viene chiamato dismettendo il controller:

[SampleViewController] timer fired
[SampleViewController] timer fired
[SampleViewController] timer fired

Analizzando il memory graph, notiamo effettivamente che il controller è ancora presente in menoria, mantenuto in vita da _NSCFTimer:

La chiave per risolvere il problema sta nel chiamare il metodo invalidate del timer:

This method is the only way to remove a timer from an RunLoop object. The RunLoopobject removes its strong reference to the timer, either just before the invalidate()method returns or at some later point.
If it was configured with target and user info objects, the receiver removes its strong references to those objects as well.

In questo caso la documentazione è abbastanza chiara: il timer viene rimosso dal relativo RunLoop e, cosa importante, viene rimosso il riferimento strong all’oggetto target del timer.

Andiamo quindi a modificare il nostro viewWillDisappear:

    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)

        timer?.invalidate()
        timer = nil
    }

Boom! Il nostro controller viene ora deallocato in maniera corretta:

[SampleViewController] timer fired
[SampleViewController] timer fired
[SampleViewController] timer fired
[SampleViewController] deinit called

Conclusioni

Nonostante la documentazione si chiara a riguardo, è un problema che trovo spesso nei progetti su cui mi trovo a lavorare e che, ammetto, mi capita di fare.

Piccola nota, il tutto è valido per i timer ripetitivi, ovvero che hanno parametro repeat: true. Per i timer che vengono eseguiti una sola volta, l’ownership viene rilasciata automaticamente.

Spero di non scordarmelo più dopo averci fatto anche un post a riguardo

The post Swift e Timer, attenzione ai retain cycle first appeared on bubidevs.

Il vantaggio di questo layout è di poter avere tutti i simboli utilizzati nello sviluppo (backtip e parentesi graffe su tutti) molto più accessibili, senza dover ricorrere a combo magiche sulla tastiera.

macOS permette di gestire diversi layout di tastiera, ma questo vi costringerà a continui cambi se, come me, passate spesso dalla vostra tastiera meccanica a quella integrata del MacBook.

Quale occasione migliore per sperimentare a fondo Shortcuts su macOS?

Idea

L’idea è quella di realizzare un comando rapido che mi permetta rapidamente di passare da un layout ad un altro, associando uno shortcut ad una combinazione da tastiera.

Il problema maggiore, tuttavia, è che, ad oggi, non esiste un’azione di shortcut che permetta di effettuare il cambio di layout. Vediamo quindi come risolvere il problema, scomodando il buon caro vecchio Carbon!

Carbon è morto, lunga vita a Carbon!

Gli sviluppatori “old school” come il sottoscritto conosceranno sicuramente Carbon. Per i più giovani, sono delle librerie presenti in macOS che permettono di interagire con il sistema operativo che sono date ormai come vecchie e deprecate da anni, ma continuano a vivere tra noi.

Proprio grazie a Carbon riusciamo a definire due script (in Swift), che ci permetteranno di:

• ottenere l’elenco delle sorgenti di input definite nella nostra installazione di macOS
• impostare la sorgente di input desiderata

Di seguito il primo script, che permette di recuperare tutte le sorgenti di input definite in macOS:

import Carbon

// retrieve all input sources
guard let cfSources = TISCreateInputSourceList(nil, false),
      let sources = cfSources.takeRetainedValue() as? [TISInputSource] else {
    exit(-1)
}

// print all sources as "name - id"
sources.forEach {
    let cfName = TISGetInputSourceProperty($0, kTISPropertyLocalizedName)!
    let cfID = TISGetInputSourceProperty($0, kTISPropertyInputSourceID)!

    let idString = Unmanaged<CFString>.fromOpaque(cfID).takeUnretainedValue() as String
    let nameString = Unmanaged<CFString>.fromOpaque(cfName).takeUnretainedValue() as String
    print("(nameString) - (idString)")
}

Eseguendo questo script, otterrete un elenco di nome / id simile a questo:

Italian - com.apple.keylayout.Italian-Pro
Emoji & Symbols - com.apple.CharacterPaletteIM
U.S. - com.apple.keylayout.US
com.apple.PressAndHold - com.apple.PressAndHold
EmojiFunctionRowIM_Extension - com.apple.inputmethod.EmojiFunctionRowItem
Dictation - com.apple.inputmethod.ironwood

Nel mio caso, le due righe di interesse sono “Italian” e “U.S.”, che torneranno in gioco a breve.

Il secondo script ci permette, invece, di settare la sorgente di input attiva:

import Carbon

let source = "com.apple.keylayout.Italian-Pro"
let filter = [kTISPropertyInputSourceID: source]

// check if the given source is available in the system
guard let cfSources = TISCreateInputSourceList(filter as CFDictionary?, false),
      let sources = cfSources.takeRetainedValue() as? [TISInputSource],
      let firstSource = sources.first else {
    print("Unable to find source '\(source)'.")
    exit(-1)
}

// select the given input source
let result = TISSelectInputSource(firstSource)
exit(result)

Andremo a breve a fare in modo che il parametro source non sia fisso, ma lo renderemo dinamico in base alla nostra necessità.

Creiamo lo shortcut

Abbiamo ora quello che ci serve per creare il comando rapido Seleziona layout tastiera che tanto desideriamo.

Il comando rapido controlla, per prima cosa, se ha ricevuto l’identificativo di un layout da impostare. Nel caso non sia fornito, richiama lo script #1 per mostrare l’elenco delle sorgenti di input disponibili e scegliere quella desiderata. Una volta scelta, richiama nuovamente lo script per impostare il layout appena scelto.

Comodo, ma possiamo fare di meglio. Possiamo definire altri due comandi rapidi, che richiamano il precedente e settano, in automatico, il layout IT o US senza necessità di interazione.

A questi due shortcut possiamo assegnare anche una scorciatoia da tastiera (rispettivamente Control + Option + Command + I e Control + Option + Command + U nel mio caso) per richiamarli ancora più velocemente.

Shortery

Il tocco finale ce lo fornire l’app Shortery, che permette di definire dei trigger per i nostri comandi rapidi (e che, per inciso, dovrebbe essere parte integrante di Shortcuts, diamine!).

In questo modo, quando la mia tastiera Bluetooth si connette, Shortery esegue il comando rapido Seleziona layout US. La sorgente di input viene subito modificata e io sono subito pronto per lavorare! Allo stesso modo, appena si disconnette viene richiamato lo shortcut Seleziona layout IT per reimpostare il layout di default italiano.

Download

Per chi fosse interessato, vi lascio i link per scaricare i tre comandi rapidi che ho mostrato nel post.

• Seleziona layout tastiera
• Seleziona layout IT
• Seleziona layout US

Se avete suggerimenti o miglioramenti, fatemelo sapere nei commenti o su Twitter.

The post Come gestire una tastiera ANSI con Shortcuts, senza impazzire first appeared on bubidevs.

Situazione attuale

Chiunque abbia utilizzato uno storyboard e i suoi segue avrà poi scritto delle istruzioni simili:

@IBAction func doSomething() {
    performSegueWithIdentifier("detailSegue", sender: nil)
}

override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {
    if segue.identifier == "detailSegue" {
        ...
    }
}

Giusto come ripasso, il primo metodo permette di invocare un segue che è stato definito nello storyboard (in questo caso ‘detailSegue’), mentre il metodo prepareForSegue:sender: permette di eseguire delle operazioni prima che il segue venga mostrato a video (tipicamente viene utilizzato per passare dei parametri o delle informazioni al controller invocato).

Questo codice, però, ha diversi problemi. Per prima cosa gli identifier dei vari controller sono hard-coded, ovvero sono delle stringhe fisse all’interno del codice, con tutti i problemi del caso (possibili errori di digitazione, poca manutenibilità del software, etc). Una soluzione spesso utilizzata per risolvere (parzialmente) il problema consiste nel definire un enumerativo che contenga i vari segue gestiti via codice:

enum SegueIdentifier : String {
   case ShowRed = "ShowRed"
   case ShowBlue = "ShowBlue"
   case ShowMagic = "ShowMagic"
}

Vediamo ora come migliorare questo metodo.

“Protocol Oriented Programming” is the way

Con Swift 2 è stata introdotta la “Protocol Oriented Programming” che, tra le varie novità che introduce, permette di definire protocolli che abbiamo già della logica definita ed implementata al loro interno. Nella sessione 411 della WWDC 2015, Apple ha mostrato come utilizzare la protocol oriented programming per migliorare la gestione dei segue. Vi consiglio di dare un’occhiata al video, contiene molti altri spunti interessanti!

Il protocollo che risolverà qualsiasi nostro problema è il seguente:

protocol SegueHandlerType {
    typealias SegueIdentifier: RawRepresentable
}

extension SegueHandlerType where Self: UIViewController, SegueIdentifier.RawValue == String {
    
    func performSegueWithIdentifier(segueIdentifier: SegueIdentifier, sender: AnyObject?) {
        performSegueWithIdentifier(segueIdentifier.rawValue, sender: sender)
    }
    
    func segueIdentifierForSegue(segue: UIStoryboardSegue) -> SegueIdentifier {
        guard let identifier = segue.identifier, segueIdentifier = SegueIdentifier(rawValue: identifier) else {
            fatalError("Invalid segue identifier")
        }
        return segueIdentifier
    }
}

Vediamo di analizzarlo nei suoi punti chiave. Per prima cosa, definiamo un protocollo SegueHandlerType, in cui al suo interno dichiariamo un typealias SegueIndentifier, che ci servirà per definire gli identificativi dei segue da gestire.

Fatto ciò, creiamo un’estensione per il protocollo (che, al momento, è ancora del tutto vuoto). L’estensione ci permette di specificarlo e dettagliarlo:

• Il protocollo potrà essere applicato solo a classi di tipo UIViewController (o che derivino da questa)
• Il typealias SegueIdentifier che abbiamo definito in precedenza dovrà avere come valore base il tipo String

I due metodi che vengono definiti dovrebbero già sembrarvi familiari. Il primo ci permette di invocare un segue utilizzando SegueIdentifier come parametro. Il secondo metodo, segueIdentifierForSegue:, merita invece più attenzione. Questo metodo riceve come parametro un oggetto UIStoryboardSegue, da cui andremo a ricavare l’identificativo del segue che sta per essere visualizzato. Utilizzando il nuovo statement guard, eseguiamo l’unwrapping dell’identificativo e convertiamolo in un valore di SegueIdentifier. Se queste due operazioni hanno successo (quindi il segue ha un identificativo valido che viene gestito nel nostro codice) il metodo ritorna il valore definito, altrimenti il metodo lancia un errore che causerà il crash della nostra applicazione. Questa può sembrare una forzatura, ma vi permetterà di scrivere codice più sicuro e robusto, gestendo tutti i segue della vostra applicazione.

SegueHandlerType in azione!

Vediamo ora un esempio di come utilizzare questo protocollo.

class HomeViewController: UIViewController, SegueHandlerType {

    enum SegueIdentifier : String {
        case ShowRed = "ShowRed"
        case ShowBlue = "ShowBlue"
        case ShowMagic = "ShowMagic"
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
    }

    // MARK: - Navigation

    override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {
        switch segueIdentifierForSegue(segue) {
        case .ShowRed:
            // logic here
        case .ShowBlue:
            // logic here
        case .ShowMagic:
            // logic here
        }
    }
    
    // MARK: - Actions
    
    @IBAction func doSomethingMagic() {
        performSegueWithIdentifier(.ShowMagic, sender: nil)
    }
}

L’enumerativo SegueIdentifier contiene la definizione di tutti i segue associati al controller. Ad ogni valore è associato l’esatto identificativo utilizzato nello storyboard, che verrà utilizzato dal metodo segueIdentifierForSegue: per ricavare il corretto enumerativo.

All’interno del metodo prepareForSegue:sender: sarà sufficiente richiamare il metodo segueIdentifierForSegue: e verificare il valore ritornato. Utilizzando uno switch, inoltre, Swift ci obbligherà a gestire tutti i casi possibili, aiutandoci così a realizzare un codice robusto e affidabile.

Il metodo doSomethingMagic, infine, mostra come invocare uno specifico segue utilizzando l’apposito metodo definito sempre nel protocollo.

That’s all folks! Una volta provato questo metodo di gestione dei segue vi assicuro che non ne potrete più fare a meno :]

Trovate il protocollo SegueHandlerIdentifier in questa repository di GitHub, mentre a questo link potete (e dovete!) vedere il video della sessione di apple alla WWDC 2015.

The post “Protocol Oriented Programming” per la gestione degli storyboard segue first appeared on bubidevs.

Per risolvere questo problema, ho rilasciato su GitHub creato un’estensione in Swift, che permette di forzare la procedura di cache della tastiera (la category originale in ObjectiveC è invece disponibile in questa repository).

L’utilizzo è molto semplice:

UIResponder.cacheKeyboard()

L’ideale è richiamare la funzione durante un’operazione già in corso, ad esempio durante una connessione ad un server remoto, in modo da minimizzare l’attesa dell’utente.

Se avete avuto lo stesso problema o avete soluzioni alternative fatemelo sapere

The post Risolvere il problema di cache della tastiera con UIResponder+KeyboardCache first appeared on bubidevs.

Lo script incrementa ad ogni run il numero di build del progetto (CFBundleVersion), che deve essere impostato in precedenza ad un valore intero iniziale (ad esempio 1).

Eccovi lo script in questione:

buildNumber=$(/usr/libexec/PlistBuddy -c "Print CFBundleVersion" "${PROJECT_DIR}/${INFOPLIST_FILE}")
buildNumber=$(($buildNumber + 1))
/usr/libexec/PlistBuddy -c "Set :CFBundleVersion $buildNumber" "${PROJECT_DIR}/${INFOPLIST_FILE}"

Utilizzo

Per utilizzarlo dovrete seguire questi semplici passi:

1. Selezionate il vostro Target in Xcode
2. Spostatevi nel tab Build Phases
3. Selezionate Add build phase -> Add Run Script Phase
   
4. Nella nuova sezione creata copiate lo script
5. Spostate la nuova fase Run Script subito sotto Link Binaries With Libraries
   
6. Verificate nell’Info.plist che il valore di Bundle Version (CFBundleVersion) sia settato ad un intero
   

Ora basterà eseguire in Run del vostro progetto per veder incrementare il numero di build.

Questo script può essere molto utile se utilizzare TestFlight, in cui non potete variare il numero di versione dell’applicazione dopo averla creata sul portale. In questo modo avrete un identificativo univoco e automatico della versione dell’applicazione che i vostri utenti stanno testando.

Sulla repository GitHub è presente anche una seconda versione dello script, che esegue l’incremento del numero di versione (CFBundleShortVersionString) durante l’Archive del progetto.

Happy coding! :]

The post Incremento automatico del numero di build in Xcode first appeared on bubidevs.