• Improving StoreKit paywall code to support flexible promotions and offers
• Transcripts support for podcast episodes
• Release management

Role: Staff Developer

Client: Automattic

Links: AppStore, GitHub repo, website

• Post+: a subscription offering for Creator in the platform to paywall their content
• Tipping: allowing tipping money to creators
• TumblrMart: a digital store that allow users to buy and gift digital items to other users.
• Important Blue Internet Checkmarks: a parody of Twitter verified
• AdFree: remove ads from the user’s dashboard
• Blaze: promote your posts

Role: Staff Developer

Client: Automattic

Links: AppStore, Web Site

www.wsj.com/articles/tumblr-introduces-paid-subscription-tool-to-woo-younger-bloggers-11626872401

xcrun simctl io booted recordVideo --codec "h264" --mask black --force ~/Downloads/Simulator-$(date +%Y-%m-%d_at_%H.%M.%S).mov

Then use the simulator as normal, and when you to finish the recording just press Crtl+C on the terminal.

You will find your video in the Downloads folder.

Note: This only works with Xcode version 11.4 and above.

FontMetrics is a straightforward application that lists all the fonts available on iOS and visualizes the typography metrics of each one.

The project was all implemented using UIKit with the help of Storyboards. It consisted of a master-detail view, wherein the master screen you select the font and then see the details metrics of the font. On the detail screen, there was a custom UITextField class that shows lines for each metric overlay on top of the text.

I started by converting the Master-Detail structure from a UINavigationViewController/UISplitViewController to a NavigationView. It was easy to do the parallel between UINavigationController with NavigationView, but only after a while, I understood that it also replaced UISplitViewController! 

If you write this:

NavigationView {
  List {
    Text("Master")
    NavigationLink("Detail", DetailView())
  }
}

On the iPhone, it will use a standard navigation view stack, but on the iPad, it will use a split view.

So this brought me took me to another question, how to define the default detail view? You add another top element to your NavigationView like this:

NavigationView {
  List {
    Text("Master")
    NavigationLink("Detail", DetailView())
  }
  DetailView() // this will be the default view
}

So that second top element will be your default detail view. If you always want to have stack navigation, you can overwrite the defaults by setting the .navigationViewStyle modifier to StackNavigationViewStyle

Moving on to the list of fonts, in UIKit, I was using a UITableViewController, in SwiftUI this maps neatly to a List view.

Here is the code:

List {
  ForEach(fontSource, id: \.self) { familyName in
    Section(header: Text(familyName)) {
      ForEach( self.fontFamilies[familyName]!, 
               id: \.self) 
        { fontName in
          NavigationLink(fontName, 
            destination: FontDetailView(
                  fontName: fontName)
              .navigationBarTitle(fontName))
        }
      }
    }
  }

Notice how much shorter is this code comparing to the UITableViewController implementation!

The only remaining thing to do on the list screen was to implement the search functionality. I found out that SwiftUI doesn’t provide a UISearchBar functionality like UIKit. One option was to wrap around the UISearchBar component using a UIViewRepresentable wrapper, but I decided to go with a custom approach:

List {
  if searchVisible {
    Section(header: Text("Search")) {
      TextField("Search", text: $searchQuery)
    }
  }
  ...
}.navigationBarItems(trailing: Button(action: {
        self.searchVisible.toggle()
      }, label: {
        Image(systemName: "magnifyingglass")
      }))

As you can see above, I added a search icon to the navigation bar that I use to toggle a text field. When visible, I use the text field to get the search word. It does not match the behaviour of a search bar entirely, but it’s good enough.

Now that we have the font list complete, let’s move for the detail screen. For the detail screen, I was also using an UITableViewController this time with a static number or rows. I could have used a List view for this element, but this time a Form view looked more appropriate.

Form {
  Section(header: Text("Preview")) {
    HStack {
      Spacer()
      FontMetricsTextView(placeholder: "Metrics", 
        text: content.wrappedValue)
      .font(font.projectedValue)
      Spacer()
    }
  }
  Section(header: Text("Size")) {
    VStack {
      Slider(value: size.projectedValue, in: 10...60, step: 1, onEditingChanged: { changing in
            self.font.wrappedValue = UIFont(name: self.fontName, size: CGFloat(self.size.wrappedValue))!
            })
      Text("\(Int(size.wrappedValue))pt")
    }
  }
  Section(header: Text("Metrics")) {
    FontMetricRowView(label: "Size:", value: font.wrappedValue.pointSize, color: .clear)
    ...
  }
}

Again look how small is this code comparing to an UITableViewController implementation.

The only surprise on this screen was that SwiftUI doesn’t offer any ready to use row types like UIKit, but it’s so easy to implement your custom rows, that it doesn’t have any impact. After all rows in SwiftUI can be any View so you can do this:

struct FontMetricRowView: View {
  let label: String
  let value: CGFloat
  let color: Color

  var body: some View {
    HStack {
      Image(systemName: "square.fill").foregroundColor(color)
      Text(label)
      Spacer()
      Text("\(value as NSNumber, formatter: Style.metricFormatter)")
        .font(Font.body.monospacedDigit())
    }
  }
}

That easy!

The only remaining work was to implement my custom UITextField to show the metrics. For this, I decided to “cheat” a bit and used a UIViewRepresentable to wrap around my custom UIKit view. Here is the code

struct FontMetricsTextView: UIViewRepresentable {

  var font: Binding<UIFont> = .constant(UIFont.systemFont(ofSize: 12))

  let placeholder: String

  let text: String

  func makeUIView(context: Context) -> FontMetricsView {
    let view = FontMetricsView()
    view.textAlignment = .center
    view.attributedPlaceholder = NSAttributedString(string: placeholder, attributes: [.font: font.wrappedValue])
    view.text = text
    return view
  }

  func updateUIView(_ uiView: FontMetricsView, context: Context) {
    uiView.font = font.wrappedValue
    uiView.attributedPlaceholder = NSAttributedString(string: placeholder, attributes: [.font: font.wrappedValue])
  }

  func font(_ value: Binding<UIFont>) -> FontMetricsTextView {
    var new = self
    new.font = value
    return new
  }
}

And with that, all the work was done! 

You can see the result of all the steps above on this PR of the FontMetrics repo in Github.

As you can see from the PR above, the end result reduces the number of lines of code by 400, and I think that the end code is simpler and easier to understand and maintain.

These are still early days for SwiftUI, and this application is very straightforward, but it looks very promising!

So how can we make our Video view compatible with macOS?

On iOS, we were using the UIViewControllerRepresentable protocol to wrap around our UIKit components. For macOS, there are the following equivalent protocols:

• NSViewControllerRepresentable
• NSViewRepresentable

Like their iOS counterparts, they allow wrapping around NSView or NSViewController in AppKit.

For our Video component in macOS, because we are wrapping the AVPlayerView, an NSView so we will be using the NSViewRepresentable protocol.

extension Video: NSViewRepresentable {
  public func makeCoordinator() -> VideoCoordinator {
    return VideoCoordinator(video: self)
  }

  public func makeNSView(context: Context) -> AVPlayerView {
    let videoView = AVPlayerView()
    videoView.player = AVPlayer(url: videoURL)

    let videoCoordinator = context.coordinator
    videoCoordinator.player = videoView.player

    return videoView
  }
  …
}

One of the cool things about his code is because the way we programmed our VideoCoordinator on part 3, it only needs to know about the AVPlayer class so we can reuse it as it is for the macOS version.

We now need to implement the updateNSView method:

public func updateNSView(_ videoView: AVPlayerView, 
                         context: Context) {
  videoView.player?.isMuted = isMuted.wrappedValue
}

The final touch is to wrap around our implementation with a compiler directive:

#if os(macOS)

extension Video: NSViewRepresentable {
…

#elseif(iOS)

extension Video: UIViewControllerRepresentable {
…
}
#endif

If you now run our demo app using a macOS application, you should see the following:

As you can see it was quite easy to adapt a component to be used on macOS, I believe this feature of SwiftUI will make it possible to develop a lot more cross-platform applications creating a new boom of development of macOS applications on the long run.

If you want to see the full example have a look at the SVEideoUI repo on Github.

Thanks for reading and see you around.

Start the demo app, notice the mute icon on the top right of the video controls, what happens if you tap on that control?

Sure thing it will mute our video, but notice that our toggle command does not update accordingly, it gets out of sync with the state of the underlying video player property.

So how can we sync between the player class and our SwiftUI Video view?

Do you remember the UIViewControllerRepresentable protocol from part 1, beside the makeViewController() and createViewController() methods there is a third method in the protocol: makeCoordinator().

The goal of this method is to create a Coordinator class, that coordinates between our SwiftUI View and the wrapped UIViewController, this looks like exactly what we need for our isMuted property. 

Let’s see how can we implement it; start by creating an internal class called VideoCoordinator:

public class VideoCoordinator: NSObject {
  let video: Video
  var player: AVPlayer?

  init(video: Video) {
    self.video = video
  }
}

Then we can implement our makeCoordinator() method:

func makeCoordinator() -> VideoCoordinator {  
  return VideoCoordinator(video: self)
}

After implementing makeCoordinator, the coordinator class will be available through the context argument in the other methods of the protocol. So now we can connect the player class to our video component.

public func makeUIViewController(context: Context) -> AVPlayerViewController {
  let videoViewController = AVPlayerViewController()
  videoViewController.player = AVPlayer(url: videoURL)
  let videoCoordinator = context.coordinator
  videoCoordinator.player = videoViewController.player
}

So how can we sync the value of isMuted between the AVPlayer object and the Video component?

If you look at the documentation of AVPlayer you will see that the properties of this class are KVO observable so that we can set a KVO observer for the muted property. Let’s do this using a dedicated method on the coordinator:

func addKVOObservers(to player: AVPlayer?) {
  player?.addObserver(self, 
                       forKeyPath: "muted", 
                       options: [.new, .old], 
                       context:&playerContext
                     )
}

And then we can use it on the didSet method of our player variable:

var player: AVPlayer? {
  didSet {
    addKVOObserver(to: player)
  }
}

We are just missing the implementation of the observer method:

override open func observeValue(forKeyPath keyPath: String?, 
  of object: Any?, 
  change: [NSKeyValueChangeKey : Any]?, 
  context: UnsafeMutableRawPointer?) {

  guard keyPath == "muted" else {
    super.observeValue(forKeyPath: keyPath, 
                         of: object,
                         change: change, 
                         context: context)
    return
  }
  if let player = player {
    video.isMuted.wrappedValue = player.isMuted
  }
}

And we are done if you start your demo app you will see that every time you tap on the mute icon on the video overlay our toggle control updates accordingly.

Just one last thing, in order to avoid crashes let’s remove the KVO observation on the deinit method:

private func removeKVOObservers(from player: AVPlayer?) {
  player?.removeObserver(self, forKeyPath: "muted")
}

deinit {
  removeKVOObservers(from: player)
}

And now we are done with our isMuted property.

Join us in part 4 to see how to make this component compatible with macOS.

For example, if you wanted to mute the sound of the video, there was no way to achieve that with our current component. Let’s see how we can change that.

We start by adding a property to our Video component called isMuted:

let isMuted: Bool = false

And then we update our makeViewController method:

let videoViewController = AVPlayerViewController()
videoViewController.player = AVPlayer(url: videoURL)
videoViewController.player?.isMuted = isMuted

Then we can set this property to on or off when we create our Video component:

Video(url: "video.mp4", isMuted: true)

If you start our demo app now, you will notice that we muted the sound of the video. All works fine if you only want to mute the sound at the creation of your Video view, but imagine you want to give the user an option to mute the sound using a toggle button? Something like this:

@State var isMuted = true
VStack {
  Video(url: "video.mp4", muted: $isMuted)
  Toggle(isOn: $isMuted ) {
    Text("Muted")
  }
}

Then you need to move our code to the updateUIViewController method:

public func updateUIViewController(_ videoViewController: AVPlayerViewController, context: Context) {
  videoViewController.player?.isMuted = isMuted.wrappedValue
}

This way, every time the toggle value is changed, our muted status updates accordingly.

Now that we have our property working, let’s make it easier for the users of our component to use it. 

One thing that you normally see in SwiftUI core components is the possibility to use modifiers instead of setting the value in the init method you change it like this:

Video(url: '...')
  .isMuted(true)

To implement this, you need to implement a straightforward method:

public func isMuted(_value: Binding<Bool>) -> Video {
  var new =self
  new.isMuted = value
  return new
}

To make it easier for users that don’t need to change the isMuted value you can implement the following helper:

public func isMuted(_ value: Bool) -> Video {
  return isMuted(.constant(value))
}

You now have your component ready to change according to the user selection. 

If you want a challenge, you can try to implement some other properties like showControls.

You can check the code for this property and other properties on the VideoUI repo in Github.

That is all for today. See you in part 3.