Nikos Maounis

First time at WWDC

2017-07-02T06:11:09+03:00

WWDC is the event of the year for the Apple developer community. The year I had the privilege to be there (it was my first time at a WWDC). WWDC17 was different than previous years as the conference moved back to San Jose after a 15 years run at Moscone West in San Fransisco. San Jose is not a new city for WWDC. The conference took place in McEnery Center from 1988 to 2002 (WWDC 2002 was the year that Steve Jobs announced the “death” of MacOS 9).

I arrived in San Jose on Saturday which is a must if you are travelling from a country with a very different timezone (I got there from Greece which is ten hours ahead of California) in order to have some time to fight jet lag and get ready for the long week ahead.

####

Sunday

Sunday is the day for badge pickup. You can pick up your badge on Monday before the keynote, but Sunday is the day to do so, as Monday is going to be a really busy day. Registration and badge pickup opened at 9am. I went in line at 8am and there were already around 50 people before me. Once the registration opens though, the line moves pretty fast. At registration you get a badge which you should not lose because they do not reissue it and a wristband which you have to wear for the whole week alongside the badge. After the badge pickup, I got in line for the swag, which included the famous WWDC jacket and, for the first time this year, some pins, including a country flag pin. After a while the line for the swag got bigger as anyone wanted to try out the jacket before leaving. Breakfast and lunch were offered on Sunday too despite the conference official kick-off was set for Monday.

WWDC badge and Greece country pin

Everyone in line is super friendly and socialising takes place everywhere inside and around the venue. Other than that Sunday is a day off so it is suitable for a trip around Silicon Valley. That is how me and some fellow developers I met there decided to spend the rest of the day. First stop of this trips couldn’t be anywhere else other than Apple Campus (the old one as the new one was not opened to public yet). There is not much to see in Apple Cupertino Campus but there is an Apple Store there that is the only one in the world that sells official Apple merchandise. Almost everyone attending WWDC visits that store, so if you want to find the tshirts you want in the sizes you want you have to get there as earlier during the week as you can.

Apple Campus, Cupertino

After Apple we visited the Google campus (Googleplex) in Mountain View, which is open for public. You cannot enter the buildings without knowing a Google employee that can get you a guest pass, but you can freely walk around the campus. Final stop was The Stanford University which needs no introduction and is in the to-do list of everyone that visits Silicon Valley. The campus is huge and its architecture and history are mind blowing and one of a kind.

Monday

Monday is the big day. Keynote starts at 10am. Everyone’s question is what time should you get to the line in order to get a good seat for the keynote. The good thing is that this year at McEnery there was a large enough hall to accommodate everyone for the keynote, so all attendees got a seat and watched the keynote live. I went in line around 7am and I got a pretty good seat on the right side. The waiting in the line is also a great opportunity for socializing and excitement and anticipation is all over the place. The Apple stuff is super friendly and once again, when the doors open around 9:30am the line moves fast.

Keynote line

After the keynote there is the Platforms State of the Union session which is kind of a keynote for developers and is the must-attend session of the week for everyone developing for Apple platforms. Developers -including me- were super excited with the new features in Xcode 9 (hello Swift refactoring) and the CoreML and ARKit frameworks. Later on Monday there was a hands on session for developers for all the new products Apple announced. Of course everyone was in front of the new iMac Pro and the new HomePod. HomePod looks much better in person than in the videos.

HomePods at hands-on area

I got a chance to try VR on the Mac using the HTC kit and the result was fully realistic and impressive but I used it for just a few seconds, so I do not have a clear opinion about it. Judging by the community reaction though, Apple is off to a good start with VR and AI.

Session & labs

The whole week after Monday is packed with sessions and labs. There are multiple concurrent sessions so plan accordingly. The WWDC app is a nice and convenient way to do that. All sessions are available online after a day or two so if two sessions that you want to attend are on the same time, just attend one and watch the other online. Labs are in my opinion the biggest privilege of being at WWDC. You get the chance to talk to Apple engineers, show them your code and get advice and guidance. It is simply amazing that you can actually talk to the people that have built the frameworks you are using and help you with any issue you have. I visited many labs about App Store, iTunes Connect, Swift and Xcode and in almost every single one of them I got my issues solved or got valuable advices. Even when my issue could not be solved right away, the Apple engineer sent me a follow-up email after a couple of days. Keep in mind that many labs are by appointment. Reservations for each day open at 7am in the morning online on the Apple developer website. So if you want to reserve a lab appointment, act fast because some labs like the UI/UX or the App Store lab have their time slots filled within minutes. If a lab is at the same time with a session you are interested to attend, just go to the lab and watch the session after through the Apple website.

Events & Bash

During the week there are multiple events and parties that take place in town. All of them this year moved from San Fransisco to San Jose. These events are a great place to meet other developers, share knowledge and socialize. Firebase party, Beard Bash by Jim Dalrymple and John Gruber’s Talk Show were some of the events that stood out this year. There also other conferences running in parallel with WWDC for those who didn’t get a ticket or for attendees that want to spend some time there too like Alt Conf and Cocoa Conf.

WWDC Bash

Apple holds its own party on Thursday night. The Bash this year took place at a park near McEnery. There was a live act, food from around the world, games and of course beer for everyone over 21 years old.

Tips for first timers

You do not need your laptop on Monday. Just an iPad or a notebook (a physical one) for keeping notes during the State of the Union is ok.
San Jose weather is much warmer than San Fransisco but during the night it gets cold so bring the appropriate clothes.
The week is long and exhausting so if you travel from far away it is better to get there on Saturday so you have the day prior to the conference free to accommodate yourself.
Visit labs. Bring your code and visit the labs to get help and advice from Apple Engineers.
Do not miss State of the Union. It is like the keynote in terms of vibes and applauses but specifically for developers and 100% techy and code oriented.
If you have a long-haul return flight, download sessions and watch them during the flight.

The feeling I got during this week can be best described using a quote that was written on a wall decoration during the conference:

A place where technology meets the liberal arts and the humanities to create new ideas that push us all forward. Where the moments you’ve lived, the songs you’ve heard, and all that inspires you find their application. This is where people unleash technology’s full potential. And vice versa. This is WWDC.

Attending WWDC was a massive experience. It is an exhausting week but it totally pays off. Talking to Apple Engineers about your code, getting advice and meeting all those talented developers from all over the world is a lifetime experience.

WWDC 2016 developer round up

2016-07-03T22:52:48+03:00

This year’s WWDC was full of surprises for developers. Apple chose the path of opening so many aspects of iOS to developers, which is something that we could not even think of some years ago. Users download more and more apps and spend more and more time on their smartphones. Apple aims to help this by eliminating the number of times users have to open apps and find what they want.

First and most visible change is the revamped lock screen. iPhone 6S and 6S Plus have so fast fingerprint sensors, that it became almost impossible to read notifications in the lock screen by pressing the home button before the screen unlocks. The only way to read notifications on a 6S on the lock screen is to use the sleep/wake button instead. In iOS 10, lock screen lights up when you raise your iPhone and notifications are presented in a much cleaner way and without dimming the background. Notifications are rich and even the widgets are right there in the lock screen. From a developer’s perspective, notifications now support rich user interfaces like seen in the image below. This means that for a third time in a row we have to change the way we register for notifications and how we handle them but this time for good. Notifications now support images too (something that was only available for bundled apps till now, for example the Messages.app) and all the APIs you would expect are there (for fetching images before triggering the notification for adding actions, etc).

Next big feature in the SDK is SiriKit. Apple is finally making Siri available to iOS developers (Siri got its way to macOS too but without a SDK for developers). Watching the WWDC sessions on SiriKit, it seems pretty straightforward to implement and the final implementation is just what the user’s expect when they interact with Siri and the built-in apps. There are APIs for registering vocabulary (localized), creating your intent UI, handle user’s input and even mark user’s input as details missing, so Siri can ask for more information. Creating a UI for Siri has some restrictions: UI cannot be interactive, for example you cannot add a map that users pinch or pan. Something that was not mentioned during the keynote is that that intent UI can be used also in the new Map extensions, which means that if you developer for Siri, you get the map extension for free.

Map extensions is the next big thing in this year’s WWDC. Apple has opened up the full power of MapKit to developers. If your app is a ride booking app or a table reservation app you can now fully integrate it with the Maps.app and let your users book a ride or table right from there. Note that this is not a deep link to your application, it is like your app running within the maps with full UI and user actions.

Next in the list are Messages and iMessage. In a few words Apple turned iMessages to a real equivalent of Facebook Messenger. Emojis are everywhere, links load directly within messages and a bunch of other cheesy effects are there. Apple got it one step further and Messages now let you replace all the suitable words within a message with their corresponding emoji. Developers can now create apps for iMessage. There can be two kind of apps for iMessage. Sticker apps that require no code from the developer, you just have to create a sticker app in Xcode 8, drag your images in the appropriate asset catalog, build, archive and submit, and apps that add functionality to messages which can range from games to collaborative apps.

Developer tools got also a lot of attention this years. I’ve been playing with Xcode 8 beta 1 since the day it came out, and I can definitely say that is much faster and smoother than Xcode 7, especially if you mix and match Swift and Objective-C code in your project. Indexing does not take a year to end and .xibs and large storyboards load much faster.

Swift 3 comes with a ton of changes that are source breaking. Xcode provides a migration assistant but it gets some time to get used to the new syntax and naming. Xcode 8 bundles also Swift 2.3 so you can build against the latest SDK and use all of the cool features of iOS 10, watchOS 3 and tvOS and move to Swift 3.0 when you are ready. A nice article on the source code changes in Swift 3.0 can be found here.

Small things that did not get much attention during WWDC are the new NSGridView on macOS which is like an enhanced StackView component and that Apple in iOS 10 marked all the iCloud core data sync methods as deprecated. Textfields also got smarter and now the predictive keyboard can also suggest all kind of data beside words, like addresses, phone numbers, emojis and urls. Last but not least code signing got much easier in Xcode 8 and this time it seems to work as advertised. Actually you do not even have to mess with certificates and provisioning if you do not want to. Xcode manages all the code signing process as expected.

Extending Swift Arrays

2016-01-24T14:42:30+02:00

Array is one of the most used collection types in Swift. Although it is extremely powerful (and the language provides much faster array iterations compared to Objective-C) it lacks many of the capabilities we were used to when working with NSArray and NSMutableArray collection types.

On easy workaround for the developer in order to deal with the missing functionality is to just cast Swift arrays to NSArray or its mutable counterpart. Another -more sophisticated- solution is to add this functionality to Swift Array, using Extensions. Extensions in Swift are what Categories are in Objective-C, an easy way to extend an existing object type with additional functionality.

Swift 2.0 added the capability to find an index of an item within an Array but it didn’t added a method to remove an object without knowing its index. Adding this is easy with an Array Extension:

import Foundation

extension Array where Element: Equatable {
    mutating func removeObject(object: Element) {
        guard let index = self.indexOf(object) else { return }
        self.removeAtIndex(index)
    }
    
    mutating func removeObjects(array: [Element]) {
        for object in array {
            self.removeObject(object)
        }
    }
}

Note that we are using mutating func here, because these functions change the value of our object. The first method finds the index of an object and removes it, while the second one does the same for multiple object.

Let’s say we need a sample method that returns a random object of our Array:

func sample() -> Element {
    let randomIndex = Int(rand()) % count
    return self[randomIndex]
}

Nothing tricky here. Let’s see a more complex example. Let’s assume that we need to shuffle our Array. We will add to methods for shuffling. One that shuffles the Array and one that returns a copy of our Array with the objects shuffled. The method that shuffles the existing Array needs to be a mutating func, while the method that returns a new Array doesn’t

mutating func shuffle() {
     if count < 2 { return }
     for index in 0..<count - 1 {
     let newIndex = Int(arc4random_uniform(UInt32(count - index))) + index
           guard index != newIndex else { continue }
           swap(&self[index], &self[newIndex])
     }
 }
    
func shuffled() -> [Element] {
      var list = self
      for index in 0..<list.count {
          let newIndex = Int(arc4random_uniform(UInt32(list.count-index))) + index
       if index != newIndex {
          swap(&list[index], &list[newIndex])
       }
      }
      return list
}

You can download a sample project with the extension here. Feel free to use it in your project or add extra functionality to it. Just the extension is also available in this Gist.

What I expect from WWDC15

2015-04-19T21:54:56+03:00

Following last year’s post about my expectations for WWDC14, this year I am going to write a similar article about what I would like to see from Apple in WWDC15. Last year’s conference was a great one for Apple Dev community. We saw many great frameworks like CloudKit, HomeKit, HealthKit, extensions and an entirely new programming language, Swift.

It is difficult even for Apple to keep up with a second straight year with such many new things for developers. Regarding OS X, I expect the next version of the Mac operating system to be what Snow Leopard was for Leopard back in 2009. A release that focuses on performance, stability and new technologies under the hood. There will be some design tweaks in the OS but I do not expect nothing special in the design area. Last year Apple redesigned the entire OS, so this year we can only expect polishing and some new touches exactly like with iOS 8.

Next big thing in WWDC15 will be iOS 9. Note that this is the first WWDC after the release of WatchKit, so I expect a lot of sessions dedicated to developing apps for the Apple Watch. I expect many improvements to the WatchKit SDK and I would love to see an SDK for native apps for the Apple Watch, but it is unlikely to be introduced this year due to the limitation of the Watch hardware (cpu power, internal storage). Access to the Watch sensors a feature that many developers would love to see. According to rumors iOS 9 will bundle few new features and the main focus area in this release will be stability and security. I totally agree with this direction. iOS needs to be refined in terms of stability. Although I do not expect to see many exciting new end user features, I expect to see new APIs especially in HomeKit and CloudKit. I would love to see an Apple TV SDK too but as with Apple Watch, the current Apple TV model has hardware limitations (internal storage), so if we see a SDK for Apple’s set top box, a new Apple TV model will be introduced too (Apple dropped the current model price in March, so a new model is very likely for introduction at WWDC).

Last but not least are the dev tools. Xcode used to be a really stable IDE a few years ago. That is far from reality after the release of Xcode 6. I’ve been using Xcode 6 from day one for large projects that include both Objective-C and Swift classes and the experience is awful. SourceKit crashes are very common (the latest version Xcode 6.3 seems to be a little better) and some times the only way to fix the lack of code highlighting is to manually delete the Derived Data folder. Even when code highlighting works, code completion is extremely slow in Swift. I totally expect Apple to refine Xcode and focus on its stability. The Swift debugger needs to be refined too and provide more accurate and useful information.

In terms of services Apple will probably (all rumors mention that) a music service similar to Spotify. If the pricing is aggressive and given the fact it will come built in with every new iPhone, it will be a huge hit. Spotify is ready to release an SDK for developers. Apple may preparing a similar surprise for its devs too…

WatchKit: Table and network fetch

2015-03-15T23:40:52+02:00

After months of beta releases, the final version of Xcode 6.2 is here. Xcode 6.2 includes the SDK for the much anticipated Apple Watch. In this tutorial we will see how to create a WatchKit app that fetches data from the network and displays a simple table and a detail view. Tables in WatchKit work a little bit different than Table Views on iPhone. The full project is available on Github.

Open Xcode and create a single view project with Swift as its default language. Leave the use Core Data checkbox unchecked. Click File>New>Target and select WatchKit app as shown in the image below.

Add a WatchKit app target in your project

After clicking next you will see a bunch of files added to your project as well as two new targets, a WatchKit extension and a WatchKit app. In order to preserve the Watch battery we will perform the network fetching on the iPhone and then pass the data to the WatchKit App. Apple provides delegate methods for such needs. Open Appdelegate.swift file and add the following code:

func application(application: UIApplication!, handleWatchKitExtensionRequest userInfo: [NSObject : AnyObject]!, reply: (([NSObject : AnyObject]!) -> Void)!) {
        
        if let request = userInfo["request"] as? String {
            if request == "refreshData" {
                var parser = XMLParser()
                parser.startParsing(NSURL(string: "http://www.ds.unipi.gr/category/announcements/feed/")!, completionClosure: {(articles, error) in
                    if error == nil {
                        reply(["articleData": NSKeyedArchiver.archivedDataWithRootObject(articles!)])
                        return
                    }
                })
            }
        }
    }

This method gets a userInfo Dictionary as input (there we can the WatchKit app asks from the iPhone app) and returns also a Dictionary. Here we have defined that we are asking for refreshData and we use a simple XML Parser (the code for the parser is available on Github alongside with the WatchKit demo used for this tutorial). After parsing the XML we need to archive the array as NSData so it can “travel” back to the Watch.

Now open the Interface.storyboard within the WatchKit app group in your project. Drag a table on your Interface Controller scene. Click the “Group” section in the Table Row Controller section and drag two Labels on the Table Row. Click the Group again and change the layout from horizontal to vertical and size to Size to Fit Content as shown in the screenshot below. Change the firs label font (the top one) to Heading.

Now add a new file in your WatchKit extension group and name it ArticleRow. Add the following code (yes, rows in WatchKit are just NSObjects)

class ArticleRow: NSObject {
    @IBOutlet weak var titleLabel: WKInterfaceLabel!
    @IBOutlet weak var detailLabel: WKInterfaceLabel!
}

Connect the IBOutlets to the row controller in the storyboard. Open InterfaceController.swift file and drag also an Outlet Connection for the Table.

Add the following code in Interface Controller file:

var articles = [Article]()
override func awakeWithContext(context: AnyObject?) {
        super.awakeWithContext(context)
        WKInterfaceController.openParentApplication(["request": "refreshData"], reply: { (replyInfo, error) -> Void in
            if let articleData = replyInfo["articleData"] as? NSData {
                if let articles = NSKeyedUnarchiver.unarchiveObjectWithData(articleData) as? [Article] {
                    self.articles = articles
                    self.reloadTable()
                }
            }
        })
    }

override func willActivate() {
        // This method is called when watch view controller is about to be visible to user
        super.willActivate()
    }

override func didDeactivate() {
        // This method is called when watch view controller is no longer visible
        super.didDeactivate()
    }

func reloadTable() {
        newsTable.setNumberOfRows(articles.count, withRowType: "ArticleRow")
        
        for (index, article) in enumerate(articles) {
            if let row = newsTable.rowControllerAtIndex(index) as? ArticleRow {
                var currentTitle: String! = article.postTitle
                let finalTitleArray = currentTitle.componentsSeparatedByString("–")
                
                var finalTitle: String = finalTitleArray[1].stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceCharacterSet())
                row.titleLabel.setText(finalTitle)
                row.detailLabel.setText(article.postDescription)
            }
        }
    }

In the awakeWithContext method, we call the parent app (our iOS app) for the data we need in order to fill the table. After getting the data we call reloadTable() (no there are no table view like delegate methods here). Note that we set text to Watchkit labels using the setText method and not dot syntax like in iOS apps. Go back to the storyboard, select the Interface Controller scene and set the class to ArticleRow in the identity inspector of the Table Row Controller and the identifier as ArticleRow in the attributes inspector.

Finally we need a detail view for our articles (the article class for the parsed objects is also included in the full tutorial code on Github). Drag a new interface controller on the Interface.storyboard in the WatchKit group and add a push segue from the ArticleRow controller to the new controller.

Drag a table on the new interface controller, add label on the row and create two new files in the WatchKit extension folder: one named ArticleDetailInterfaceController and called ArticleDetailRow. Set the same settings for the group layout and size for this controller. For the label set the number of lines to 0. Set the table row controller class and the identifier to “ArticleDetailsRow”. Add the following code to each of the newly created files.

import WatchKit
import Foundation

class ArticleDetailInterfaceController: WKInterfaceController {
    var article: Article!
    
    @IBOutlet weak var articleDetailTable: WKInterfaceTable!
    
    override func awakeWithContext(context: AnyObject?) {
        super.awakeWithContext(context)
        
        if let article = context as? Article {
            self.article = article
            self.reloadTable()
        }
    }
    
    //MARK: Table loading
    func reloadTable() {
        articleDetailTable.setNumberOfRows(1, withRowType: "ArticleDetailsRow")
        
        if let row = articleDetailTable.rowControllerAtIndex(0) as? ArticleDetailRow {
            var articleDescription: String! = article.postDescription
            row.textLabel.setText(articleDescription)
        }
    }
}

import WatchKit

class ArticleDetailRow: NSObject {
    @IBOutlet weak var textLabel: WKInterfaceLabel!
}

Connect the IBOutlets for the table and the row to the storyboard. After all the connections are in place select the segue and add “articleDetails” as identifier in the Attributes Inspector tab. Open InterfaceController.swift file and paste the following code in order to trigger the segue when a cell is tapped.

override func contextForSegueWithIdentifier(segueIdentifier: String,
        inTable table: WKInterfaceTable, rowIndex: Int) -> AnyObject? {
            if segueIdentifier == "articleDetails" {
                let article = articles[rowIndex]
                return article
            }
            
            return nil
    }

Click and run the app. In order to see the WatchKit app, select the WatchKit app from the schemes and when the iOS Simulator launches, click Window>Displays and select one of the available WatchKit displays. The full code for this project can be found on Github.

iOS SDK: Pop up window in Swift

2015-01-31T20:21:12+02:00

One of the most popular posts in my blog is the tutorial for creating a Pop-up window with iOS SDK using Objective-C. Since then many readers reached me out asking for a Swift version of the Pop-up. In general the process is exactly the same in Swift (except the language used to write the code of course…), so I am not going to dive into the process of creating the .xib files again. For this you can always refer to the original post.

The Pop-up controller is a subclass of UIViewController with a couple of methods for the fade in and fade out animations.

override func viewDidLoad() {
        super.viewDidLoad()
        self.view.backgroundColor = UIColor.blackColor().colorWithAlphaComponent(0.6)
        self.popUpView.layer.cornerRadius = 5
        self.popUpView.layer.shadowOpacity = 0.8
        self.popUpView.layer.shadowOffset = CGSizeMake(0.0, 0.0)
    }
    
    func showInView(aView: UIView!, withImage image : UIImage!, withMessage message: String!, animated: Bool)
    {
        aView.addSubview(self.view)
        logoImg!.image = image
        messageLabel!.text = message
        if animated
        {
            self.showAnimate()
        }
    }
    
    func showAnimate()
    {
        self.view.transform = CGAffineTransformMakeScale(1.3, 1.3)
        self.view.alpha = 0.0;
        UIView.animateWithDuration(0.25, animations: {
            self.view.alpha = 1.0
            self.view.transform = CGAffineTransformMakeScale(1.0, 1.0)
        });
    }
    
    func removeAnimate()
    {
        UIView.animateWithDuration(0.25, animations: {
            self.view.transform = CGAffineTransformMakeScale(1.3, 1.3)
            self.view.alpha = 0.0;
            }, completion:{(finished : Bool)  in
                if (finished)
                {
                    self.view.removeFromSuperview()
                }
        });
    }
    
    @IBAction func closePopup(sender: AnyObject) {
        self.removeAnimate()
    }

In the viewDidLoad method, I styled the PopUp with rounded corners. You can customize that for square corners or other shadow styles. Note that in Swift we have to implement also the required init(coder aDecoder: NSCoder) and as we’ve created the UI in interface builder using .XIBs the override init(nibName nibNameOrNil: String!, bundle nibBundleOrNil: NSBundle!) method has to be added too. Add these two methods and we are almost done:

required init(coder aDecoder: NSCoder) {
        super.init(coder: aDecoder)
    }
    
    override init(nibName nibNameOrNil: String!, bundle nibBundleOrNil: NSBundle!) {
        super.init(nibName: nibNameOrNil, bundle: nibBundleOrNil)
    }

Now that the PopUp is implemented, we have to call it from the view where we want to display it.

self.popViewController = PopUpViewControllerSwift(nibName: "PopUpViewController", bundle: nil)
self.popViewController.title = "This is a popup view"
self.popViewController.showInView(self.view, withImage: UIImage(named: "typpzDemo"), withMessage: "You just triggered a great popup window", animated: true)

A fully working example alongside with the Objective-C and Swift code for the PopUp is available on Github. Feel free to use it in your projects and if you find any issue or glitch, do not hesitate to open an issue on Github.

A video version of the tutorial is provided by Webucator.

iPhone screencast with iOS 8 and OS X Yosemite

2014-10-24T23:05:19+03:00

Over the years, iOS developers have used various tools in order to record screencasts for their apps. Starting with OS X Yosemite this process became much easier. Using the built-in Quicktime app in iOS Yosemite, we can now easily record our iPhone’s or iPad screen. The steps are pretty straightforward:

Open QuickTime in OS X Yosemite
Plug your iPhone using the USB cable
Choose File>New Movie recording from QuickTime menu
Select the iPhone screen as the input camera as shown in the image below
Note that you can rotate the iPhone in order to record landscape screens <p style="text-align: justify;"> </p>

Note that there is no ability to show touches in your screencast (a functionality that most third party screencast tools are offering) but it is nice to see a built in way to record iOS device screens especially now that Apple offers the ability to upload video previews alongside screenshots to the App Store.

Thoughts on iOS 8

2014-06-07T15:56:01+03:00

As almost all Apple developers, I was excited with the announcements Apple made in WWDC this year. Lots of new stuff, a revamped OS X experience, a new iOS version with refinements for the end user and great new APIs for developers and a whole new programming language: Swift.

Last year Apple completely redesigned its mobile operating system, leading to a lot of criticism, although most reviews where positive. iOS 7 was new and fresh but in many ways it seemed like an unfinished product. Except the icons, I loved the new design for iOS. My main issue was that it was the same OS with a new coat of paint. This year, with iOS 8, Apple did exactly the opposite. It kept the appearance of the OS almost the same, refined the user experience, added subtle but meaningful new features and proved huge new opportunities for developers. The slogan in iOS’s website: “Huge for developers, massive for everyone else” describes the new version of iOS exactly as it is. End users will have almost the same experience using the stock apps, but third-party apps built for iOS 8 will provide a bunch of new features.

So lets start with the end-user features enhancements. The most notable new feature is the revamped messages app. Users will be able to mute group conversations, see all the attachments in a thread at once, and share their location with other users in the same thread. Also you can know capture sound or video and share it with others with a single swipe. These all are features provided by other apps for years, but seen them built in with Apple elegance is a nice addition to the whole experience.

Second noticeable feature are the recent and favorites contacts addition to the multitasking screen. This will provide a fast way to call or message all of your favorite contacts. Keeping with the UX refinements, Apple finally gave iOS one of the most wanted features: widgets. Widgets will be available in notification center, providing at a glance info to anything the user chooses, similar to the stock widget in iOS 7.

Huge changes -though not eye catching- come also to the photos.app. iOS 8 will store all the user photo to iCloud. This will give instant access to your whole photo library from all your devices, while also freeing some storage from your iPhone (most users’ iPhones have gigabytes of photos).

Another great new feature for users that have more than one Apple device is HandOff. With HandOff users will be able to continue their work exactly where they left it in another device with a simple swipe in the home screen (or by clicking the blinking app icon if we are talking about OS X). This, with the addition of iCloud drive, makes finally Apple’s cloud service something more than a hobby, and a solution worth thinking of using it for something else than just device backups and app data. 5GB are to few though, but thanks to the new pricing, bigger storage plans are way more affordable than before.

iOS 8 might not be a big release in terms of end-user features but it builds on top of iOS 7 with some needed refinements. It is iOS 7 as it should be, exactly like what Mountain Lion was to OS X Lion.

Now lets dive into the huge part of the story: APIs. I plan to cover the developer releases announced in WWDC14 in depth in a separate post, but iOS 8 related APIs worth a brief mention in this article. iOS 8 will bring extension. In simple words, app developers will be able to add extensions to safari, photos.app etc. For example Pinterest will be able to provide the Pin-It functionality straight in Mobile safari, without the need to leave the browser for pinning something to your boards. In the same way editing a photo with Instagram and sharing it will be possible inside the photos.app. Extension will be able to project UI to other apps. Next is Home Kit. Home kit will provide a standard API for home automation apps. This will explode apps of this kind, as now developers have to develop their own protocols to communicate between their apps and their hardware. Last but not least is HealthKit. iOS 8 has a new app (the only new one) called Health. Health is all your health related data organized within an app. User can add data related to his health manually. But apps built in with HealthKit will be able to aggregate user’s health data (with permission from the user of course) and provide data that will be visible to Health app. Imagine that you are using to apps like Runkeeper to track your activities. If both apps are built using HealthKit, you will be able to see your activity summary (from both apps) in the Health.app.

I’ve installed the first beta of iOS 8 in an iPhone 4S since day one and I have to admit that I experience far less crashes than I did with iOS 7 beta. Performance is also tweaked and 4S seems to handle the new OS fine even though the hardware is 3 years old.

Thoughts on OS X Yosemite

2014-06-04T10:48:39+03:00

During the WWDC keynote last Monday, Apple unveiled the next version of OS X. The new version of OS X is called Yosemite and alongside a new design it comes also with great features.

So let start with the design. I have to admit that after the radical redesign of iOS 7 last year, I expected the same thing to come to the mac with Yosemite. I expected a completely flat look, very simplified -even childish- icons, with translucency in some places to give a sense of depth. Instead of that -and I am very happy for this- Apple chose to maintain the mac elegant aesthetics and make it more modern and eye appealing. A touch device, like iPad and iPhone, is a completely different use case from a desktop where the user uses a mouse and has to deal with multiple open windows. Instead of providing almost the same experience in both desktop and touch devices (like Microsoft does with Windows 8), Apple brought the same in design language in the mac but kept the desktop characteristics of its operating system almost untouched. So windows still have shadows (more subtle than before), icons are richer than their iOS counterparts and fonts are not ultra-thin like in iOS 7. System font in OS X Yosemite is changed from Lucida Grande to Helvetica Neue which brings the system in line with the iOS platform. Icons have brighter colors, but they maintain their shape variation and some light shadows. Translucency is used in sidebars, title bars and the new notification center, providing a sense of depth and context and making the whole os feel more elegant and polished. The use of white space is much less in OS X Yosemite compared to iOS, but compared to Mavericks it is much more. I do not think that the amount of white in the new system will cause eye bleeding to all of us who spent many hours a day in front of our mac display, but if you think so, Apple built in a dark mode in Yosemite, which will probably be one of the most loved design changes (especially from devs and designers).

OS X 10.10 will have a dark mode. Devs will love it @goldstein #WWDC14

— Nikos Maounis (@Psy2k) June 2, 2014

Except the design revamp, the new version of OS X comes with a ton of new features. And these features in most cases demonstrate exactly what Apple does. Instead of unifying the desktop and mobile OSes, it unifies the experience. The biggest improvements come to the messages.app. In Yosemite, when your iPhone is nearby, you can receive and send iMessages as well as SMSs from the built in message.app. You can even receive and place phone calls exactly like you placed Facetime calls up to now. Another great features is Continuity. With continuity you start something in your Mac (like a document, spreadsheet etc) and your iOS device is notified immediately, so with a simple swipe in your home screen, you can continue your work from your other devices. Mail.app got also a huge feature bump. The biggest new feature in mail is the built in markup capability. You attach an image, and you can add shapes, text, and callouts by drawing on the Multi‑Touch trackpad. Also using mail drop you can send up to 5GB attachments with mail. If the recipient uses mail.app, he gets the mail in his inbox with the attachment inside, exactly like before. If he uses another client, he gets the mail with a link to download the attachment from iCloud. Personally although I love these enhancements, I do not know if I will leave Airmail for mail.app after last year’s fiasco with the gmail accounts. Last but not least is iCloud drive. In simple words, iCloud drive is Apple’s answer to Google drive and dropbox. A folder in the finder that syncs across all your devices and keeps your documents organized per app.

Later this year Apple will release a new photo.app for the App with all the editing and organizing capabilities found in the iOS Photo.app. This photo.app will serve many of the duties of iPhoto, so it has to be seen what the future of iPhoto will be.

Worth mentioning is that this year Apple made the OS X beta available to all registered developers (not only those enrolled in the Mac dev program) and it will also give access to beta testers applied for the Mac beta program.

For the last 5 years Apple has focused almost on iOS, providing the mac with subtle improvements. I love that this year OS X got so much attention. Yosemite is the next step for OS X and compared to the previous steps it i a giant step forward which makes the mac look modern, even more sophisticated and the Apple ecosystem more unified than ever.

I didn’t mention anything about the new dev tools in this post, because there are so many new things for developers in iOS 8, Yosemite and Xcode 6 that they worth a separate post.

Xcode 5: Test UITableView with XCTest framework

2014-04-27T13:27:41+03:00

In WWDC 2013, Apple introduced Xcode 5 and iOS SDK 7 with a built-in framework for testing: XCTest.framework. Unfortunately Apple documentation lacks details for this framework. In this post I am going to present a simple way to test a UITableView using XCTest framework.

First, we need an Xcode project with a simple UITable. Open Xcode and create a new single-view application project. Open the storyboard file and drag a UITableView onto your view controller.

In the identity Inspector set “testTableView” as the Storyboard ID. Open up the ViewController.m file and place the code to poulate the dummy UITableView (do not forget to connect the IBOutlet to the TableView in the storyboard):

#import "ViewController.h"

@interface ViewController ()

@property (weak, nonatomic) IBOutlet UITableView *tableView;

@end

@implementation ViewController

#pragma mark - View loading methods
- (void)viewDidLoad
{
    [super viewDidLoad];
    self.title = @"XCTest Tutorial";
	// Do any additional setup after loading the view, typically from a nib.
}

#pragma mark - Memory warning methods
- (void)didReceiveMemoryWarning
{
    [super didReceiveMemoryWarning];
    // Dispose of any resources that can be recreated.
}

#pragma mark - UITableView delegate methods
-(NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
    return 15;
}

-(NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {
    return 1;
}

-(UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    NSString *reuseId = [NSString stringWithFormat:@"%ld/%ld",(long)indexPath.section,(long)indexPath.row];
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:reuseId];
    if(!cell)
    {
        cell =[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:reuseId];
        cell.selectionStyle = UITableViewCellSelectionStyleGray;

    }

    cell.textLabel.text = [NSString stringWithFormat:@"Row %ld", (long)indexPath.row+1];

    return cell;
}

@end

As you can see the code is pretty self-explanatory. We just create a UITableView property with 15 rows and print the row number in each row (note that in your ViewController.h file you have to declare that the controller conforms to UITableViewDatasource and UITableViewDelegate protocols).

As you can see, I declared the UITableView property in my .m file interface section (which is the correct way to do it, because there is no need in our case to expose the UITableView to our .h file so it can be accessed by other classes). But we need to access it from our XCtest class. The easy solution would be to just move the declaration to the .h file, right? Yes, but it is not the most sophisticated solution. What are we going to do, is create a class extension which exposes the UITableView property for us. To do this, navigate to File>New>New file and create a Objective-C class extension file.

Name the file “Private” and select ViewController as the class. Open up the newly created header file and just redeclare the UITableView there as shown in the following snippet:

#import "ViewController.h"

@interface ViewController ()

@property (weak, nonatomic) IBOutlet UITableView *tableView;

@end

Connect the IBOutlet in the tableView in the storyboard again. Now we are ready to write some tests for our UITableVIew. Open up the Tests.m file which is automatically created by Xcode 5 with every new project. Import the private header file we just created and declare a ViewController property:

#import <XCTest/XCTest.h>
#import "ViewController_Private.h"

@interface XCTestTutorialTests : XCTestCase

@property (nonatomic, strong) ViewController *vc;

@end

The first thing we want to test is that the view loads and has a UITableView as subview. In the setup method we put the code we want to run before each test -in our case we just want to load the viewcontroller- and in the teardown method we put the code we want to run after each test invocation:

- (void)setUp
{
    [super setUp];
    UIStoryboard *storyboard = [UIStoryboard storyboardWithName:@"Main" bundle:nil];
    self.vc = [storyboard instantiateViewControllerWithIdentifier:@"testTableView"];
    [self.vc performSelectorOnMainThread:@selector(loadView) withObject:nil waitUntilDone:YES];

    // Put setup code here. This method is called before the invocation of each test method in the class.
}

- (void)tearDown
{
    // Put teardown code here. This method is called after the invocation of each test method in the class.
    self.vc = nil;
    [super tearDown];
}

#pragma mark - View loading tests
-(void)testThatViewLoads
{
    XCTAssertNotNil(self.vc.view, @"View not initiated properly");
}

- (void)testParentViewHasTableViewSubview
{
    NSArray *subviews = self.vc.view.subviews;
    XCTAssertTrue([subviews containsObject:self.vc.tableView], @"View does not have a table subview");
}

-(void)testThatTableViewLoads
{
    XCTAssertNotNil(self.vc.tableView, @"TableView not initiated");
}

The testThatViewLoads method checks that the viewcontroller’s view is not nil. Pretty simple test to check that a view is initiated. The testParentViewHasTableViewSubview tests that our view has UITableView subview and the testThatTableViewLoads tests that our tableView is not nil. Next we have some tests for the UITableView property:

#pragma mark - UITableView tests
- (void)testThatViewConformsToUITableViewDataSource
{
    XCTAssertTrue([self.vc conformsToProtocol:@protocol(UITableViewDataSource) ], @"View does not conform to UITableView datasource protocol");
}

- (void)testThatTableViewHasDataSource
{
    XCTAssertNotNil(self.vc.tableView.dataSource, @"Table datasource cannot be nil");
}

- (void)testThatViewConformsToUITableViewDelegate
{
     XCTAssertTrue([self.vc conformsToProtocol:@protocol(UITableViewDelegate) ], @"View does not conform to UITableView delegate protocol");
}

- (void)testTableViewIsConnectedToDelegate
{
    XCTAssertNotNil(self.vc.tableView.delegate, @"Table delegate cannot be nil");
}

- (void)testTableViewNumberOfRowsInSection
{
    NSInteger expectedRows = 15;
    XCTAssertTrue([self.vc tableView:self.vc.tableView numberOfRowsInSection:0]==expectedRows, @"Table has %ld rows but it should have %ld", (long)[self.vc tableView:self.vc.tableView numberOfRowsInSection:0], (long)expectedRows);
}

- (void)testTableViewHeightForRowAtIndexPath
{
    CGFloat expectedHeight = 44.0;
    CGFloat actualHeight = self.vc.tableView.rowHeight;
    XCTAssertEqual(expectedHeight, actualHeight, @"Cell should have %f height, but they have %f", expectedHeight, actualHeight);
}

- (void)testTableViewCellCreateCellsWithReuseIdentifier
{
    NSIndexPath *indexPath = [NSIndexPath indexPathForRow:0 inSection:0];
    UITableViewCell *cell = [self.vc tableView:self.vc.tableView cellForRowAtIndexPath:indexPath];
    NSString *expectedReuseIdentifier = [NSString stringWithFormat:@"%ld/%ld",(long)indexPath.section,(long)indexPath.row];
    XCTAssertTrue([cell.reuseIdentifier isEqualToString:expectedReuseIdentifier], @"Table does not create reusable cells");
}

The code is pretty easy to understand. Note that in every assertion we have an expression and a format. The format acts like [NSString stringWithFormat:] by default, so there is no need to use stringWithFormat there.

Unit Tests are an essential part of a modern development flow and is nice to see that Apple acknowledges it and provided a framework for that. Unfortunately XCTest does not offer a way to create mock objects. To do that you have to rely on a third party framework like OCMock. You can download the demo project used in this tutorial from Github.

What I expect from WWDC 2014

2014-04-13T14:44:19+03:00

Apple will hold its annual developers conference in San Francisco in June. WWDC will kick off on June 2nd in Moscone West. As every year the web is full of (accurate and inaccurate) rumors regarding what does Apple have in its pipeline. Based on the various rumors, I’ll write about what I wish from Apple this year.

It is clear that as last year was iOS year, this year’s WWDC hot announcement is going to be about the mac mainly. Since Mac OS X Leopard, tha mac operating system has seen incremental updated in terms of user interface (in terms of features much has changed since then. Even the rewrite of Finder in Cocoa alone that was released in Snow Leopard is a huge under-the-hood change). Last year Apple did not change OS X UI, not because Johny Ive thinks that it is ok, but because no company -even Apple- can handle two operating systems revamps in a single year. So they just decided to start with iOS, which definitely needed an overhaul, its UI seemed dated for a long time.

So, following the trend I will start my wishlist with OS X. I think that OS X needs a UI update, but not a huge revamp like the one we saw last year in iOS. OS X is already flatter and cleaner than iOS 6. A good example of where OS X is going are the apps that Apple updated or added last year: Xcode, Calendar, iBooks, iMovie and Garageband and the iWork suite. All these feature a clean, content centric UI with simple -not shadow heavy- buttons (especially Xcode and iWork) and more white space. I see these changes taking place across the system and all the current inconsistencies throughout the system will get sorted out. It is clear that last year Apple did not have time to go further with OS X. They removed the cheesy UI from the calendar.app and the notes.app but they did not do the same with messages.app, reminders.app and game center.

A big chapter in the design of OS X are icons. I hope that we do not see huge changes in the app icons. Icons are and should be art, not clip-art like the icons Apple has chosen for iOS 7. Also all those pastel and neon colours on the desktop (where people probably do productive stuff) will be a huge eye pain. I expect we get translucency here and there, like in the notification center. Another point of Apples current direction are shadows. Apple completely removed shadows from it mobile OS. On the desktop shadows are needed at least at windows, so the eye can quickly distinguish the active window. Even not as heavy as the shadows used in Mavericks, they should definitely be present in the next version of OS X.

In terms of features, I would love to see a window managing system in OS X. Microsoft did it great in Windows 7, so Apple can do it too (and do it even better). Airdrop should finally be the same Airdrop for all devices, allowing file exchange between the Mac and iOS devices. Siri would be a nice addition too, but personally I do not use it much in iOS either.

My please-Apple-don’t-do-these list contains a few things that I personally do not want to see them ported to the mac from iOS. First of all borderless buttons. This just doesn’t work on a desktop OS (it does not even work on a mobile OS but this is another story). Second in my don’t-list are ultra thin fonts. Apple presented iOS 7 with Helvetica-Neue light, which was a pain to read in iOS devices with retina displays. During the betas they changed the font to Helvetica-Neue regular which is much better but it remains thin. Such a font in the desktop would be a mess. Not all users have retinas displays, and computers are used all day long for work. Having to read such a thin font for 8 hours a day, especially in white backgrounds will cause our eyes to bleed. Apple knows all these and knows the reaction from end users to many of iOS UI decisions they’ve made, so I am sure that they will not do the same decisions on OS X.

Regarding iOS 8, I expect it to be an incremental update like iOS 6 was. Healthbook will definitely be one of the new features as fitness market seems to be the new trend. I expect some slight UI changes in iOS (like the UI changes in iOS 7.1), so things get better and I hope (but I do not expect it) that Apple will improve many of its default apps’ icons to make them look they are made by Apple and not a 1st grade student.

As every year before, we will probably see some new hardware in WWDC. I think that time has come and Apple will release a retina macbook air (there are rumors for a retina 12″ macbook air without a fan). I would love to see a revamped apple tv with an app ecosystem (and an SDK for devs). The current Apple TV has 8GB of storage used for the OS, artworks and caching. So even if we see an Apple tv app store, I do not think that it will be available for current Apple TV models.

Retina iPad mini review

2014-01-17T18:51:29+02:00

Display quality on the retina mini is impressive

I’ve been using the 1st gen iPad mini for about a year now. My main issue was the display quality and recently -after iOS 7 release- its speed. When Apple released the retina iPad mini this year, I thought that they finally released the mini as it should be since last year: an iPad with the same specs as the full size iPad but with smaller -and not worse- display.

I got the black and space gray 32GB iPad mini. From the outside it seems the same as the previous generation. The only difference is that it is a little bit thickier than the 1st gen (unnoticeable if you don’t put them side by side) and a little bit heavier. The same happened to the full size iPad when it got a retina display. The other two hardware differences that are noticeable is the back (if you get the black model) which is now gray. This change is probably because of manufacturing issues as anodizing aluminum can be a tough process. The other difference is the addition of a second microphone on the back for noise cancelation and better facetime call quality.

Biggest change in the new mini of course is the retina display. This is the same display that is used in the iPad Air which means 2048×1536 resolution, but due to the smaller form factor of the mini, it translates to 326 pixels per inch. The difference between the old and the new display is huge. Text now looks sharp (reading in the old mini was painful for the eyes, text was fuzzy) and images have vivid colors and crystal clear quality. The A7 processor seems to have no problem driving all those pixels and the best of all is that battery life is not affected either. To achieve that battery life with the new display, Apple made a lot of changes under the hood. Battery in the new mini is a two cell battery with much higher capacity than its predecessor (there comes the extra weight and thickness). Energy consumption is also benefited from the new M7 co-processor (the same as in the iPhone 5s). M7 collects data from the accelerometer, the gyro and the compass offloading work from the A7 chip and because it is designed for that purpose only, it much more energy efficient in these tasks compared to the A7. In real everyday usage I get the same battery life as the 1st gen mini.

Black and Space Gray Retina iPad mini

Talking about the chips inside the new retina mini, I have to mention how far the processing power of these machines has come. The A7 processor is fast. Actually is so fast and powerful that Apple didn’t need an “X” version (like the A5X and A6X in previous iPads) to give its tablets enough horse power for the demanding retina displays. Compared to the previous generation mini the difference in performance between the A5 and A7 chips is huge especially if you’ve used your 1st gen mini with iOS 7. Animations and transitions feel much smoother, applications launch extremely fast and graphics performance is top of the class. Actually you can play Infinity Blade 3 for hours without a single lagging frame. You have to see this in person, but even with such processing power hungry games, the A7 shows that it can handle much more. The A7 is also the first 64-bit chip in mobile devices. Of course not all the apps have been optimized for 64-bit but it is a move in the right direction. In the near future all iOS apps will have been optimized to take full advantage of the 64-bit technology. With the latest Xcode Apple has made it a piece of cake to compile for both 32 and 64-bit and retain support for iOS 5 and 6. Suddenly not all 3rd party libs have been updated for the new architecture (best example is google analytics) and in my opinion this is the main reason why there are so few 64-bit apps in the App Store.

Overall I am extremely happy with the new mini. I was also happy the 1st gen because of it portability (I think that 8-inch tablets are the best) but I missed the retina display and after updating to iOS 7 it became also a little bit laggy. Another point here is that because iOS 7 makes heavy use of thin fonts and thin UI elements, it looks too fuzzy and corrupted in non retina displays. On the other hand in the retina display of the new iPad mini, iOS 7 looks elegant and extremely sharp. The Retina mini solves all these issues and from now on, deciding which iPad you will get is just a matter of taste regarding the screen size.

iOS SDK: Create a Pop Up window

2013-12-10T01:16:36+02:00

iOS – Popup window

In an iOS project I am currently working on, I was requested to create a pop-up window. Trying to figure out how to do it, I came up with a solution that is pretty easy to implement and very straight forward. All you need is a view controller with a transparent background and a subview (your popup window). After creating the popUpViewController, you can just call it from any other view controller.

Lets see the implementation in depth. First we create a new objective-c class with .xib file. In the header file (.h), add the following code (we need the QuarzCore framework in the project to style the window with rounded corners and shadows):

#import <UIKit/UIKit.h>
#import <QuartzCore/QuartzCore.h>
#import "AppDelegate.h"

@interface PopUpViewController : UIViewController

@property (weak, nonatomic) IBOutlet UIView *popUpView;

- (void)showInView:(UIView *)aView animated:(BOOL)animated;

@end

After that edit the .xib file so it looks like the one in the image below.

Interface Builder view of the popup window.

Now connect the popUpView outlet to the view in the .xib file (the view highlighted int he above image). Next, open the .m file of your class and add the following lines in your viewDidLoad method, so the background view of the window looks transparent:

- (void)viewDidLoad
{
    self.view.backgroundColor=[[UIColor blackColor] colorWithAlphaComponent:.6];
    self.popUpView.layer.cornerRadius = 5;
    self.popUpView.layer.shadowOpacity = 0.8;
    self.popUpView.layer.shadowOffset = CGSizeMake(0.0f, 0.0f);
    [super viewDidLoad];
    // Do any additional setup after loading the view from its nib.
}

Note that we set the backgroundColor alpha and not the view alpha because the popup window is a subview of the background view and we do not want it to look transparent too. In the viewDidLoad method we also set the shadow of the window and the cornerRadius (in order to get rounded corners).

Finally lets implement the code that does the trick with pop up fade in and fade out:

- (void)showAnimate
{
    self.view.transform = CGAffineTransformMakeScale(1.3, 1.3);
    self.view.alpha = 0;
    [UIView animateWithDuration:.25 animations:^{
        self.view.alpha = 1;
        self.view.transform = CGAffineTransformMakeScale(1, 1);
    }]; 
}

- (void)removeAnimate
{
    [UIView animateWithDuration:.25 animations:^{
        self.view.transform = CGAffineTransformMakeScale(1.3, 1.3);
        self.view.alpha = 0.0;
    } completion:^(BOOL finished) {
        if (finished) {
            [self.view removeFromSuperview];
        }
    }];
}

The showAnimate method scales the view to 1.3 (130%) of its current size, sets the alpha to 0 and then invokes an animation block with a duration of 0.25 sec that scales the view down to its original size and sets the alpha to 1. The removeAnimate method does exactly the opposite and implements also a completion handler for the animation block, so we know when to remove it from its superview.

Finally we need the IBAction for the close button, so the removeAnimate method is called and the implementation for the showInView method that we declared in our .h file in order to show our popup window on top of other views. The code here is self-explanatory:

- (IBAction)closePopup:(id)sender {
    [self removeAnimate];
}

- (void)showInView:(UIView *)aView animated:(BOOL)animated
{
    [aView addSubview:self.view];
    if (animated) {
        [self showAnimate];
    }
}

Connect the IBAction to the “Close” button you’ve added in your .xib and you are done. The output will look like this:

Popup demonstration

The code is available on Github alongside with a simple view that demonstrates how this popup can be invoked from other view controllers. A new post regarding the Swift implementation of the PopUp is also available here.

Review: Iconic Book: A Photographic Tribute to Apple Innovation

2013-11-03T12:57:48+02:00

Macbook Air 13″ on top of the Iconic Book

Ten days ago, I’ve came by “Iconic Book: A Photographic Tribute to Apple Innovation” while surfing the net. First thing that crossed my mind was: “Wow that the Apple Bible”. I immediately ordered my copy ($75 cost for the book plus 50$ for ship costs -I live in Greece-). Three days ago I found a note in my door, that I have a parcel waiting for me in my nearest post office. Next morning I got it. First impression? This book is much bigger than I thought it would be. It is elegant, printed in high quality paper, exactly like an Apple book should be.

Iconic Book is a photo book with all Apple products from 1976 up to iPhone 5 and iPad mini. The writer, Jonathan Zufi, a 42-year-old Australian native, begun buying vintage Apple products 4 years-ago. He collected a ton of products and started taking photos of them. Well known Apple personalities -including Steve Wozniak- helped him and the result was outstanding: a collection of more than 150,000 photos, some 3,500 of which Mr. Zufi displays on a website and more than 650 of which he has curated into a new 326-page coffee-table-sized book, the Iconic Book.

The book is broken down into six main sections: desktops, portables, peripherals, iDevices, prototypes and packaging. The prototypes section is the most fascinating, lot of stuff that never came to light in there. I also enjoyed the peripherals section. I’ve used mac since 6-year old (the first mac that I remember at home was my father’s Quadra, but I never new that Apple has built a point to shot camera.

Apple QuickTake Camera

As the writer mentions in an interview in the WSJ:

“I wanted to create a repository where people who also love the company and its products could go and reminisce, I want people who are a bit younger who think Apple just makes things that start with “i” to know this company used to make clunky printers.”

And that his books exactly does. His book’s focus is on the large pictures that sometimes span both pages, but the quotes sewn throughout the pages are just as powerful. Jonathan Ive’s, Tim Cook’s and of course Steve Jobs’ words are everywhere. Navigating the pages of this book is like watching Apple product introductions from 1984 till 2013.

This slideshow requires JavaScript.

Iconic book is pricey -especially if you live outside the US and the shipping cost is high- but like every Apple product it definitely worths it. Print quality is high and even with very little text, it manages to travel you through Apple’s evolution throughout the years. A must-have for every Apple fan out there. Period.

Migrating to modern Objective-C

2013-10-26T22:00:40+03:00

Last year at WWDC 2012, Apple introduced Modern Objective-C alongside iOS 6. So what’s this? In a few words, it is a huge step forward to help developers write less code to achieve the same things. Worth mentioning is that modern Objective-C has nothing to do with iOS versions, it has to do with the compiler, which means that it is backward compatible.

Let’s dive into the basics of transitioning to modern Objective-C. Xcode offers a refactoring tool (edit>Refactor>Convert to Modern Objective-C syntax) which will convert your project to modern Objective-C (it will also set the appropriate flag in build settings). If you would like to adopt modern Objective-C when writing your code, which is the best, as it is intended to help you write less lines of code, general rules for doing so are the following.

Default property synthesis

Usually iOS developers declare a property in the header file and have to synthesize it in the implementation file in order to access it. With modern Objective-C there is no need to synthesize properties. All properties are synthesized automatically and you can access them using the property name prefixed with an underscore. For example you declare this property in your header (.h) file

@interface MyViewController : UIViewController

@property (strong, nonatomic) IBOutlet UILabel *myLabel;

@end

In the implementation file you can access your UILabel using:

_myLabel.text = @"Great, no need to synthesize properties";

NSNumber Literals

Up to now, initializing an NSNumber involved a considerable amount of typing and calling class methods to describe the value type you are going to put on that NSNumber. Typical examples are:

NSNumber *number1 = [NSNumber numberWithInt:154];
NSNumber *number2 = [NSNumber numberWithFloat:154.243f];
NSNumber *number3 = [NSNumber numberWithBool:YES];

In modern Objective-C, the above code looks just like this:

NSNumber *number1 = @154;
NSNumber *number2 = @154.243f;
NSNumber *number3 = @YES;

Array Literals

Working with NSArray objects is also simplified in modern Objective-C. The old way of initializing an NSArray was like the below sample code:

NSArray *cityArray;
cityArray = [[NSArray alloc] initWithObjects:@"Athens", @"Paris", @"London", @"Berlin", @"Oslo", nil];

Now we can just initialize an NSArray as follows:

NSArray *cityArray;
cityArray = @[@"Athens", @"Paris", @"London", @"Berlin", @"Oslo"];

Note that in modern Objective-C there is no need to nil terminate an NSArray object. Also when writing the above code, the compiler generates:

id objects[] = { @"Athens", @"Paris", @"London", @"Oslo" };
NSUInteger count = sizeof(objects) / sizeof(id);
cityArray = [NSArray arrayWithObjects:objects count:count];

The same shortening applies also when accessing an NSArray object. So instead of:

NSString *secondCity = [cityArray objectAtIndex:1];

we can now use just:

NSString *secondCity = cityArray[1];

Dictionary Literals

Initializing an NSDictionary object follows the same concept like NSArray literals. So usually we initialize an NSDictionary like that:

NSDictionary *cityListing = [NSDictionary dictionaryWithObjectsAndKeys: object1, key1, object2, key2, object3, key3, nil];

Up to now NSDictionaries needed to be nil terminated like NSArrays. In modern Objective-C the initialization is like the code snippet bellow. Note that now reading an NSDictionary initialization method is also match easier, thanks to the “:” separating each object with its key.

NSDictionary *cityListing = @{key1 : object1, key2 : object2, key3 : object3};

As with NSArrays, when writing this code, the compiler generates:

id objects[] = { object1, object2, object3 };
id keys[] = { key1, key2, key3 };

NSUInteger count = sizeof(objects) / sizeof(id);

cityListing = [NSDictionary dictionaryWithObjects:objects forKeys:keys count:count];

Accessing values and objects of an NSDictionary is also simplified, so instead of:

NSString *city = [cityListing objectForKey:key1];

we just type:

NSString *city = cityListing[key1];

For a further look on modern Objective-C syntax, you can refer the llvm website here. As seen from these simple code snippets, a lot of common initializations and declarations get much simpler -and actually faster- with the new syntax. It is fair to say that the transition to modern Objective-C is the next big step after moving to ARC for iOS/Mac developers.

Extend UIImageView class to easily add border to images

2013-07-28T23:22:23+03:00

When coding for iOS, I usually style images with shadows so the layout looks more elegant. Adding shadows is easy, but when it comes to adding borders to UIImageViews things become trickier. That’s because when adding a border to a UIImageView, this border hides info from the image. To solve this issue, we have to rescale the image and then add the border to the scaled image.

Let’s do how can we do it by extending UIImageView class (it’s object oriented programming, so it is nice to have reusable classes, isn’t it?). First, we have to create a new Objective-C class. We name our class UIImageViewAddBorder.h and .m accordingly. In UIImageViewAddBorder.h, we define our interface as shown below:

#import <Foundation/Foundation.h>;

@interface UIImageView (ImageViewBorder)

-(void)setImage:(UIImage*)image borderWidth:(CGFloat)borderWidth;

@end

This functions receives as input an image with border width. Now lets fill the implementation file. In our .m file we need a function to scale down the image. This method should look like this one:

-(UIImage*)scaleDownImage:(UIImage*)image{
UIImage* scaledDownImage = image;

CALayer* layer = self.layer;
CGFloat borderWidth = layer.borderWidth;

if (borderWidth > 0)
{
CGRect newRect = CGRectMake(0.0, 0.0, self.bounds.size.width - 2 * borderWidth, self.bounds.size.height - 2 *borderWidth);

if (image.size.height > newRect.size.height || image.size.width > newRect.size.width)
{
UIGraphicsBeginImageContext(newRect.size);
[image drawInRect:newRect];
scaledDownImage = UIGraphicsGetImageFromCurrentImageContext();
UIGraphicsEndImageContext();
}
}
return scaledDownImage;
}

This function gets the original image, calculates a new rectangle (the original minus the border width) in which the new image should fill in, scales down the image and returns the scaled image.

Adding the border in the image can be done with the code below. This snippet is pretty self explanatory.

-(void)addImageViewBorder:(CGFloat)borderWidth
{
CALayer* layer = [self layer];
[layer setBackgroundColor:[UIColor grayColor].CGColor];
[layer setBorderWidth:borderWidth];
[self setContentMode:UIViewContentModeCenter];
self.clipsToBounds = YES;
[layer setBorderColor:[UIColor whiteColor].CGColor];
[layer setShadowColor:[UIColor blackColor].CGColor];
layer.shadowOpacity = 0.6;
layer.shadowOffset = CGSizeMake(0.0f, 0.0f);
layer.shadowRadius = 5.0f;

}

Finally we implement the public method that calls the rescale and border methods as follows:

-(void)setImage:(UIImage*)image borderWidth:(CGFloat)borderWidth
{
[self addImageViewBorder:borderWidth];
UIImage* scaledDownImage = [self scaleDownImage:image];
self.image = scaledDownImage;
}

Now it is time to test what we have done. You can just create a ViewController, import UIImageViewAddBorder.h, and call the following to any UIImageView you want to apply a border:

[myImageView setImage:myImage borderWidth:3.0];

where “myImageView” is the name of your UIImageView.

I made the class available on Github with an example implementation, so feel free to check it out here.

Thoughts on OS X Mavericks

2013-07-07T13:56:35+03:00

Alongside iOS 7 in WWDC, Apple also announced a new version for its desktop operating system. The new version is the first OS X version that is not named after a cat. From now on OS X will carry names of famous places in California. First in this new naming series is OS X 10.9 Mavericks.

For the past couple of years, apple has chosen to release new OS X versions every year with incremental updates that bring iOS features to the Mac. This started with Lion, continued with Mountain Lion and is some way continues with Mavericks too. But Mavericks some also some great new features under the hood (more on that later) that remind me of Snow Leopard feature list (Snow Leopard had few new features regarding end-user experience, but introduced many new technologies under the hood).

So lets dive into the new feature-set of Mavericks. First comes iBook porting to the Mac. Apple has three digital stores: app store, itunes and ibook store. The last one was the only one missing from the company’s desktop os, so it is no surprise to see that iBooks app finally make its way to the Mac. iBooks for Mac brings all the expected functionality of iBooks with a clean design without any skeuomorphism. User can buy books, read them, keep notes, add bookmarks and of course all this stuff is synced across devices as expected. Textbooks will probably look great on the Mac and will have huge impacts in education.

Next new feature is another app that was available on iOS: Maps. Apple created a desktop client for its Map solution. Map for OS X carries all the feature from its mobile sibling: Flyover, local search etc. But in my opinion what makes maps on os x so great is the integration with the Apple ecosystem. For example, like many of us do when searching for a location, you search for a place in Maps on OS X, get directions, hit a button and boom: directions are sent to your iPhone and you are ready to go. But apple didn’t stop there. In calendar (which also got rid of all the skeuomorphic design) when you add a new event and attach a location to it, you can now choose how will you travel there (for example on foot, or by car) and it automatically adds the travel time to that event, so you will not schedule anything during that time.

Safari 7 will also make its debut to os x mavericks. The new version of Safari has a much more clean interface (top sites are just boxes without that curved design, reading list got rid of all the clutter) and features also a “shared links” tab which shows all the links shared from people you follow on Twitter. Javascript execution is said to be much faster in the new Safari and memory footprint much smaller thanks to some memory management improvements made under the hood.

As expected, iCloud Keychain will be available on the Mac too. You save your credentials there and they are available across all your devices. Notifications got a huge improvement too. Now you can interact with notifications right from the notification center. For example you receive an iMessage. No you can reply straight from the notification center, without having to open the Messages app. Websites can also send notifications in os x mavericks, and if you have locked your screen or put your mac to sleep, when you return you’ll see a summary of the notifications you received.

Another great feature in mavericks is support for multiple displays. Actually this is not a new feature, it is an old one, but this time it is made right. Dock and menu bar will be available to all of your displays and yes, now you can run different full screen apps in each displays without messing up.

Last but not list is the Finder. Finder got support for tabs, which will probably remove much of the clutter of our desktop. Besides tabs, finder also got tags support. Tagging has been proved as a very useful way for organizing things. You can simply apply current tags with drag and drop in the tab window in finder, or create new ones will saving a file. Efficient and elegant additions for managing your files.

Regarding performance of os x, apple added some great new technologies, promising to make your mac work faster and more efficiently. First of these technologies is Timer Coalescing. Timer Coalescing groups low-level operations together, creating tiny periods of idle time that allow your CPU to enter a low-power state more often. On top of that comes another new technology, called App Nap. App Nap helps you save power when you’re working with multiple apps at the same time. Mavericks can tell when an app is completely hidden behind other windows. And if that app isn’t currently doing something for you App Nap conserves battery life by slowing the app down. But as soon as you start to use it again, the app instantly shifts back to full speed. Apple claims that this shift back is so seamless that the end user will think that the app has been working all the time (and the good news is that all the os x mavericks up to now agree with this). Safari tabs also got some app nap like features, so now when an app is inactive it does not get resources from the os. Compress memory -another new technology- is aimed to handle memory in a more efficient way, freeing up memory for your apps. As your Mac approaches maximum memory capacity, OS X automatically compresses data from inactive apps, making more memory available.

OS X Mavericks will be available this Fall, and can be installed to all the Macs running Mountain Lion. I believe that Apple is in the right way with OS X. OS X is years ahead Windows, has a solid unix foundation which makes it stable and secure and Apple pushes small incremental updates (regarding end user features) each year. But these new features are valuable to the end user. Users get used to them and think of them as mandatory after a while. For example, me as an end user, I am happy with the way finder works in OS X Mountain Lion. But I am sure that after a short period of time using Mavericks, there will be no way back to a Finder without tabs and tags. Same had happened with Notification Center last year. Under the hood improvements are also a huge part in Mavericks. With all these new technologies your laptop can save much battery life. Gaining 1 hour of battery life with just software improvements cannot be underestimated.

For developers Mavericks brings map kit of course, sprite kit for creating 2D games, all the technologies for energy efficiency and multiple displays and LinkedIn integration within apps.

Thoughts on iOS 7 beta

2013-06-30T23:27:14+03:00

As every year at WWDC, this year Apple announced a new version of its mobile operating system: iOS 7. This version is a radical departure from any other iOS release. From design perspective it is entirely new. It also has some nice new features (but I still believe that the most feature rich update in iOS history is iOS 5 which introduced iCloud, iMessages, OTA updates and WiFi syncing).

Lets start with the design. First of all -as with all iOS releases- not all features of iOS 7 will be available on all devices. Devices eligible for update are iPhone 4, iPhone 4S, iPhone 5, latest iPod touches, iPad 2, iPad mini and all iPads with Retina Displays. iOS 7 comes with a new icon set, which has raised a debate across the web regarding the wrongness of the icons. Personally I like the new icon designs, but I would prefer the colors to be less saturated. This would be the ideal icon set for me. But icons are only a small part of the new interface. iOS 7 has a sense of movement and depth. Wallpapers are live, which means that you can put a panorama image as background and while moving the phone you can see different parts of the image in the background (it is called parallax effect and you have to see it live to release how cool it is. And yes, it will soon -if not already- be copied by all the Androids. Or maybe not? Parallax effect uses the 6-axis gyroscope built in every iPhone to proved that movement which makes it very realistic. Not all smartphones have gyros, so it will be difficult to copy this or even if copied, to make it look so smooth and realistic like on an iPhone. I tend to think that Apple had it in mind when designing iOS 7. It had the clear goal, to make it so sophisticated and tried to bind it with as many hardware sensors of its devices it could, so it will be difficult to copy it.

Next big chapter in the new iOS is typography. Here with no doubt Apple made a great job. The font across the entire system is Helvetica Neue. Text rendering is perfect accross the system. Text is sharp, most of the times on white background, which makes it extremely easy to read. Many function buttons in iOS 7 (like the “back” button, or the “shuffle” and “repeat” button in the Music.app) have no shape, they are plain text. That may seem strange at first glance, or confusing, but after a while you get used to it, although I’d still prefer buttons with a light shape around to inform the user that this area is touchable.

Other nice additions in the UI are the ability to have pages in folder, meaning that you can now have more than 12 apps per folder, the new UISwitch control with the minimal animation and the overall translucency across the system which provides a sense of depth.

Now that we’ve show the exterior of the new operating system, lets see the interior. Apple packed a bunch of new features in the new iOS release. First is the Control Center. Control Center gets revealed like the notification center (but with the opposite gesture, from bottom to top). In my personal opinion Apple did a big foul regarding the Control Center and the lock screen. When the phone is locked you seen the well known “slide to unlock” label (without borders to define the touchable area) and below that there is an arrow pointing the top, meaning to inform that Control Center is also accessible via the lock screen. But the whole positioning of these buttons and the lack of borders around “slide to unlock” label give the sense that the user should slide from bottom to top in order to unlock the device.

Next feature worths mentioning is the revamped Multitasking UI. Apple chose the right path here. Multitasking now shows the state of the app, and you can kill an app with just a swipe.

iTunes Radio -or otherwise the Pandora killer- is another new feature. iTunes Radio is a free radio service, that plays songs you like and learns from what you hear. Of course it gives you the ability to purchase the tracks you listen from iTunes. iTunes Radio will have also ads, except if you have an iTunes Match subscription.

In the field of security, iOS 7 provides the ability to sync your passwords across all your devices with iCloud keychain. Also if you lose your phone and you have find my iPhone enabled, the phone is locked and it should be activated again with a valid Apple ID. Siri will get also some new capabilities (like searching in Wikipedia), but the most notable change is Siri’s new user interface. The camera app follows also the trend of all these photo apps, and comes packed with filters. Safari has a new UI too, which I personally like a lot as it provides a very clean user experience focusing in content. Adding to that it now lists all the URLs in your Twitter timeline, who posted them, and what they had to say about them. Photo app is also completely revamped with a new UI that groups your images according to date and places.

Last but not least is Airdrop. Airdrop (which is available in OS X since Lion) lets you exchange files. Although Airdrop will not be available in older devices, it is a nice enhancement on how iOS users share files.

Talking about features availability: Parallax effect will not be available on iPhone 4 (parallax needs gpu horsepower. Adding that to the iPhone 4 would probably lead to poor and laggish user experience). Airdrop will be available on iPhone 5, iPad 4 and iPad mini.

I have to admit that when I saw WWDC keynote I was shocked with the radical change in iOS. But after I downloaded the beta and tried it, the more I use iOS 7, the more I like it. Using iOS 7 for a couple of hours and then getting back to iOS 6 is like feeding me with old food. In general I was not a big fan of heavy skeuomorphism. I liked the way pages turn in iBooks app, but that wooden bookshelf or the casino-table like interface in Game Center were not my best. But skeuomorphism aimed to help people understand and learn easily how to use iPhones and iPads some years ago. No all people know how to use them, so I think that Apple did the right thing by choosing to follow a more elegant, clean and content centric path for its mobile operating system.