DEV Community: Jordan Osterberg

Realm Database Guide - Building a Note app in Swift for iOS

Jordan Osterberg — Fri, 04 Jan 2019 03:49:31 +0000

If you prefer videos over written articles, this article is a written version of a video I produced. The content is identical.

This video is the first in a series that I hope will serve to teach you how to use iOS frameworks and tools such as Siri Shortcuts, CloudKit, and more. If you have a specific framework or feature you'd like to see this series cover, feel free to write me at jordan[dot]osterberg[at]shadowsystems[dot]tech, or on Twitter @josterbe1.

Introduction
Installing Dependencies
The Model
Implementing Realm
Conclusion

Without further ado, let's take a look at the application we're going to build in this series...

Introduction

We have our list of notes, and when we tap into one, we can read and begin to edit, or delete it. Pretty simple. You'll notice if you download the starter project that notes don't persist when you go in and out of the NoteDetailController when tapping on the "Apple Park Visit" note. That is, the content of the note doesn't save when you edit it.

That's what we're going to build out in this article, using the Realm Database. I've used Realm for just about two years, and I find its simplicity to outweigh the cost of using a 3rd party library. In fact, I use it in the app I spend most of my personal development time on (see https://countdowns.download) on both macOS and iOS.

Installing Dependencies

In order to begin using Realm, we need to install it using CocoaPods. CocoaPods, if you're not aware, CocoaPods is a dependency management tool that is widely used in the iOS space. If you don't have CocoaPods installed on your Mac already, you can use the sudo gem install cocoapods command to get started. Now, open the project folder, as well as a Terminal window inside of that directory.

Type in pod init, and then open Podfile.

Inside of the newly created "Podfile", we need to write some text which will inform CocoaPods what libraries you'd like to install into your project.

Below # Pods for NotesApp, write these two lines:

pod 'Realm', '~> 3.12.0'
pod 'RealmSwift', '~> 3.12.0'

Your Podfile should look similar to this after you've written those lines:

platform :ios, '12.0'

target 'NotesApp' do
  use_frameworks!

  # Pods for NotesApp
  pod 'Realm', '~> 3.12.0'
  pod 'RealmSwift', '~> 3.12.0'

  target 'NotesAppTests' do
    inherit! :search_paths
  end

  target 'NotesAppUITests' do
    inherit! :search_paths
  end

end

Now that we've added our dependencies, let's ask CocoaPods to install them with pod install

This will take some time when you first use CocoaPods. Don't worry, CocoaPods is just downloading some initial components. This won't happen every time you pod install.

Your Terminal window will look like this once that command finishes executing:

After this, if you've opened the NotesApp.xcodeproj already, close out of it. When using CocoaPods, you must use the .xcworkspace file instead of the default .xcodeproj file. Open the NotesApp.xcworkspace file and head to Note.swift.

The Model

This class contains our Note model object, which contains a few basic properties:

class Note {

    var identifier: String
    var content: String
    var lastEdited: Date

    init(
         identifier: String = UUID().uuidString,
         content: String,
         lastEdited: Date = Date()) {
        self.identifier = identifier
        self.content = content
        self.lastEdited = lastEdited
    }

}

Standard model code, nothing special going on here.

We also have an extension to our Note object in the same file, which subclasses as protocol called Writeable

extension Note: Writable {

    func write(dataSource: DataSource) {
        self.lastEdited = Date()

        dataSource.store(object: self)
    }

    func delete(dataSource: DataSource) {
        dataSource.delete(object: self)
    }

}

Inside of the write and delete functions, you'll notice we have a DataSource property. DataSource is a generic protocol to help make modifying data as abstract at the higher levels of our code as possible.

Here's the protocol definition:

protocol DataSource {

    func store<T>(object: T)
    func delete<T>(object: T)

}

If you're not familiar with generics, each of our functions has a T parameter which essentially means it can be any type of object. This isn't used very heavily in our project, but it could be evolved and used further to create multiple DataSources with different constraints around what objects they can store.

We implement our DataSource protocol in NoteDataSource. There isn't anything special here either, aside from one little tidbit I'd like to note for explanation's sake.

Whenever we store or delete objects, we use the following call to NotificationCenter:

NotificationCenter.default.post(name: .noteDataChanged, object: nil)

// We also have this extension of Notification.Name to make sending and receiving this notification simple.

extension Notification.Name {

    static let noteDataChanged = Notification.Name(rawValue: "noteDataChanged")

}

Essentially, whenever any note is stored or deleted, we inform any listeners that our data has changed, so they can update their UI accordingly.

With all of our model files and classes out of the way, let's begin implementing Realm!

Implementing Realm

There are three steps to integrate Realm with our project:

Creating the Realm Object
Bridging between our Realm object and our primitive Note object
Begin retrieving and modifying data with Realm

Creating the Realm Object

This step is relatively simple. Let's create a new Swift file called RealmNote.swift. Inside of RealmNote.swift, import the RealmSwift framework and create a class declaration like so:

import RealmSwift

class RealmNote: Object {

}

We'll subclass Realm's Object class which will allow us to use RealmNote in Realm database functions.

Now, add in the three properties that we have in our Note model:

@objc dynamic var identifier: String = ""
@objc dynamic var content: String = ""
@objc dynamic var lastEdited: Date = Date()

The @objc dynamic pieces of our variable declaration expose our properties to Objective-C, which many of the iOS layers of Realm are written in. It also allows Realm to listen for changes to our RealmNote objects.

To finish off our class, override the class func primaryKey, which returns an optional string (String?) with the value "identifier". This informs Realm that RealmNote's primary key, a way to uniquely identify our objects, is stored in the "identifier" property.

Once you've completed these steps, your RealmNote will look like this:

class RealmNote: Object {

    @objc dynamic var identifier: String = ""
    @objc dynamic var content: String = ""
    @objc dynamic var lastEdited: Date = Date()

    override class func primaryKey() -> String? {
        return "identifier"
    }

}

That's all for step one.

Bridging between our Realm object and our primitive Note object

We have two separate model objects: Note and RealmNote. RealmNote is used internally when dealing with Realm, in order to keep our model layer decoupled from our UI. By using two separate objects, we could switch away from using Realm in the future if the need arrises.

In the RealmNote.swift file, create an extension of RealmNote:

extension RealmNote {

}

Now, create a convenience init inside of the extension which takes in a Note as it's only property. This will allow us to create RealmNote objects by using a Note object.

convenience init(note: Note) {
    self.init()

    self.identifier = note.identifier
    self.content = note.content
    self.lastEdited = note.lastEdited
}

Great, now, to finish RealmNote.swift off, create a Note variable inside the extension which initializes from a RealmNote:

var note: Note {
    return Note(realmNote: self)
}

Don't worry if Xcode gives you an error about Note's initializer, we're about to fix that.

Head over to Note.swift, where we're about to write the other half of our bridge. This code is essentially the same thing as RealmNote's extension.

extension Note {

    convenience init(realmNote: RealmNote) {
        self.init(identifier: realmNote.identifier, content: realmNote.content, lastEdited: realmNote.lastEdited)
    }

    var realmNote: RealmNote {
        return RealmNote(note: self)
    }

}

Great, that's step two. We can now access a RealmNote from a Note, and a Note from a RealmNote. This also means that this code is perfectly valid:

Note(content: "Example").realmNote.note.realmNote.note.realmNote.note.realmNote
// and so on...

Jokes aside, let's finish our application with step three.

Begin retrieving and modifying data with Realm

Head into NoteDataSource.swift, and import RealmSwift before the class declaration. Before we modify, delete, and retrieve Realm objects, we need an instance of the Realm Database. Replace NoteDataSource's init with this:

var realm: Realm

init() {
    // Load our data
    self.realm = try! Realm()
}

This will create an instance of the Realm database. In production, you'd likely not want to use the bang (!) operator when creating the instance because your application will crash if the database isn't available.

Next, let's edit the store function to actually store objects into our database.

Writing with Realm is simple:

try? self.realm.write {

}

Inside of that code block, we can update objects within the database. Write this:

self.realm.add(note.realmNote, update: true)

This will either create a new RealmNote in the database or update an existing one if one exists. That's it! We're now storing objects in the Realm database (calling note's write function is performed in NoteDetailController.swift if you'd like to see the function that is actually used to perform this write.)

Now, let's write our delete function. Because of the way we wrote our bridge (without consulting Realm whenever we create a RealmNote from a Note), we must fetch the object directly from the database using the note's identifier rather than using it's realmNote property.

This is simple:

if let realmNote = self.realm.object(ofType: RealmNote.self, forPrimaryKey: note.identifier) {

}

This asks Realm to retrieve a RealmNote object from the database, with the identifier, or primary key, of note.identifier.

This can be a bit funky. For some reason, the application crashes if we use the traditional write function on Realm. As a workaround, this code is perfectly valid and essentially performs the same task as write:

self.realm.beginWrite()
self.realm.delete(realmNote)
try? self.realm.commitWrite()

We begin our write, we delete the object, and we commit our write.

With that, we've built a functioning note application!

Conclusion

I hope you've enjoyed this tutorial on how to use the Realm Database. I've had a lot of fun making it and I can't wait to evolve this series and add more features to our app over time such as Siri Shortcuts, CloudKit, and more. Thanks for reading.

"You've won a WWDC18 Scholarship."

Jordan Osterberg — Fri, 20 Apr 2018 23:19:51 +0000

Dear Jordan Osterberg,

Congratulations! You’ve been awarded a WWDC18 Scholarship, which includes a ticket to the conference, lodging for the week, and one year of membership in the Apple Developer Program.

Let's back up for a moment. Back to 2016. I had just started learning Swift, how to build iOS apps, and Apple had just announced WWDC16. At this time I had roughly 3 weeks of developer experience with Swift. I'll obviously get in, right? This year was funky, because I really didn't prioritize it and I ended up not submitting anything at all. This wasn't a worry for me, I would just apply and get in next year!

Or so I thought. Nope! I had much more development experience this time around, however Apple requested we build using a platform I had little experience in. This, combined with performance issues with my submission, landed me a rejection for this year's scholarship. This sucked. I had been really looking forward to going to WWDC that year and the rejection email hit like a bus. I set a goal that next year, I would put forth 10x the effort as I had in 2017.

You can see my post about implementing Accessibility into this year's submission here, in which I go over some bits and pieces as to how I built my submission. Here is a video of part of my submission.

4/20/18

No, that is not a weed joke. That's the day Apple had set as judgement day, where all of the applicants would be notified of their status. An email with the subject line of "Your WWDC Scholarship Status" meant you had been hit with a rejection. The entire week I had been lowering my outlook, trying to lessen the blow that I knew was eventually coming.

I couldn't focus at all the entire school day, keeping the Slack channel that other applicants chat on open in all of my classes. Lunch hit, I had ordered a pizza to either celebrate or recover. I walked up to the office, waiting for a pizza that was supposed to arrive at 12:15. It was 12:30, and no pizza arrived. I took a look at the Slack channel (I had it open on my phone) and saw the onslaught of emails from Apple with statuses. (Side-note: I had removed my email account I submitted with from my phone and MacBook Pro so I wouldn't prematurely see the email from a notification. I wanted to go out on my own terms.)

I logged into my email provider's web portal, and there I saw it.

"You've won a WWDC18 Scholarship."

I worked myself to death over this thing, every free moment I got was dedicated to building my submission.

It appears my hard work has paid off :)

I'll be writing articles throughout the week of the conference (June 4th to 8th) on the new technologies, and at the end of the week I'll post an article on my entire experience.

Accessibility in your software | iOS & VoiceOver

Jordan Osterberg — Mon, 02 Apr 2018 00:00:06 +0000

This post was written on March 23rd, 2018 to be published on April 1st at 5:01 PM PST, in order to prevent duplicates of my scholarship submission

Accessibility should be a priority for every developer and product manager. Period.

Let me take a step back for a few moments.

While working on my scholarship application for Apple's WWDC18 conference, my submission concept looked like this over the weeks leading up to, and during the time period where we could submit:

Leading up to the announcement, I was going to use ARKit to build an "About Me" app in the Augmented Reality space, and use some real-time effects on it to make myself appear as a hologram within the world while giving sort of a presentation on my programming career. Luckily, I didn't work on this idea too in-depth like I saw many other applicants attempt around January to February.

Then, Apple decided to make this year's scholarship requirement a "Swift Playground" (they did this last year as well, but collectively the applicants I talked to didn't think this would be the case again) which is an Apple-made programming learning tool for the iPad.

As soon as Apple announced the conference and scholarship process for this year, I went to work right away, scrapping my idea and brainstorming a few new ones. One of them was to create a 2D game that used AR to display a map of the level in the player's living room. Eventually that idea transformed into making what's called a PlaygroundBook that had the same content, except it would teach the reader how to create their own 2D game.

Fast forward to Wednesday of this week (March 21st, 2018) I had essentially finished my submission and was ready to begin testing it extensively on my different demographics. However, I felt it was missing something.

Accessibility. That's what was missing. I added a few messages using Apple's VoiceOver technology for different actions, such as "Cat moving right" (the cat is the player in the game), "Cat stopped moving right", and "Cat collected fish. You have 3 fish."

This was cool. A brand new category of users could now use the game.

Or could they?

It turns out, the controls were impossible to use with VoiceOver. You just couldn't change between them fast enough and the game required you to do so in order to navigate the level. In order to solve this problem, I grouped controls into two sections: The right and left sides of the screen. The game requires you move and jump in either direction at once, so why not check if VoiceOver is enabled, and then only use one button for each side of the screen? Whenever it's touched, the cat both moves and jumps. Problem solved.

The moral of the story is to always, always, always look for ways to implement Accessibility. Be creative! Solve these incredibly important problems.

This project can be found on my WWDC submissions repo, where I archive each year's submission I submit to the scholarship.

Here's a video of most of my submission: https://www.youtube.com/watch?v=pt4cq_p6Img

And here's a video of the Accessibility Experience: [link coming soon]

I hope this inspires you to implement Accessibility in your own software, and hopefully gives you some insight as to how challenges like these can be overcome with creative design :)

From Storyboards to Code in iOS (Episode II)

Jordan Osterberg — Wed, 10 Jan 2018 22:54:07 +0000

EPISODE II
From Storyboards to Code in iOS

SWIFT has replaced STORYBOARDS in JORDAN OSTERBERG'S iOS career. Swift has dominated all of the new projects, and all of the old projects have had their storyboards stripped out and replaced with code.

But there is a complication. AUTO-LAYOUT code is difficult to write, and takes too much time.

What will Jordan do to continue fighting storyboards and improving his workflow?

If you haven't picked up on that reference by now, it's from Star Wars.

Let's recap what we learned in Episode I, "From Storyboards to Code in iOS" (https://dev.to/osterbergjordan/from-storyboards-to-code-in-ios).

Recap

Storyboards are great for learning how to make iOS apps.
Storyboards lose their greatness as soon as you deal with the auto-layout system, as it is completed to use.
Storyboards don't thrive in large projects, requiring either many storyboards or other solutions
Using code can solve these problems!

Great.

Let's transition into problems with using code to create your layouts.

Problems with the Solution

The code can be bulky and span long horizontally. This is never good. We want our code to be nice and readable, not huuuuuuuuuuuuuuuuuuuuuuuuuge strings of text. (See what I did there?)
The code can be difficult to understand. This can be difficult wether you're a new programmer or a senior programmer who's worked with auto-layout from day one.
There are many pieces that are essential, and forgetting them will break your layout. (e.g. translatesAutoresizingMaskIntoConstraints or isActive)

Solutions for the Problems with the Solution

Complicated title, I know. But the great news is the solutions I've created aren't so complicated. I've begun writing a library called EasyConstraints that's a simple UIView extension in a single swift file.

Let's create a view called redView.

let redView : UIView = {
    let view = UIView()
    view.backgroundColor = UIColor.red
    return view
}()

Here's some auto-layout code to center redView in our root view, and make it 100x100.

self.view.addSubview(self.redView)

self.redView.translatesAutoresizingMaskIntoConstraints = false
self.redView.centerXAnchor.constraint(equalTo: self.view.centerXAnchor).isActive = true
self.redView.centerYAnchor.constraint(equalTo: self.view.centerYAnchor).isActive = true
self.redView.widthAnchor.constraint(equalToConstant: 100).isActive = true
self.redView.heightAnchor.constraint(equalToConstant: 100).isActive = true

Great. Now let's use EasyConstraints to do the same thing.

self.view.addSubview(self.redView)

self.redView.centerHorizontally(in: self.view)
self.redView.centerVertically(in: self.view)
self.redView.setWidth(equalTo: 100)
self.redView.setHeight(equalTo: 100)

And we're done. Much easier to remember and understand. This method also returns an NSLayoutConstraint which can be seen in the example project.

I want to mention that this is a WIP, or work in-progress library. Not all of the auto layout constraints have nice and easy to use methods, and all of the features I want to add are not present in this version. Here's a list of all of the current methods, and some I plan on adding as soon as I get a chance:

Current Methods:

centerHorizontally | in: UIView
centerVertically | in: UIView
equalWidth | to: UIView
equalHeight | to: UIView
setHeight | equalTo: CGFloat
setWidth | equalTo: CGFloat
placeBelow | view: UIView, distance: CGFloat
placeAbove | view: UIView, distance: CGFloat
placeRightOf | view: UIView, distance: CGFloat
placeLeftOf | view: UIView, distance: CGFloat

Planned Methods/Features:

Add constant (CGFloat) argument to equalWidth and equalHeight
Add modifier (CGFloat) option to all applicable methods
Bundle methods together to make life even easier
More "place" like methods such as placeAbove or placeBelow

I'm sure I have more ideas of what to add, and I'll update this list as they come to me. You can check out the library and it's evolution at https://github.com/JordanOsterberg/EasyConstraints. If you have any suggestions or features that would make EasyConstraints easier or "cooler" please let me know.

ARKit + Vision: An intriguing combination

Jordan Osterberg — Sat, 15 Jul 2017 02:56:25 +0000

After multiple weeks of pondering what I should do first with Apple's newly announced ARKit, I decided that I wouldn't narrow my mindset to just that one API. I had viewed multiple tutorials on CoreML/Vision's object recognition features, and I decided to give it a shot myself.

TL;DR: ARKit and Vision is an awesome combination.

What are we doing?

We're going to create an ARKit app that displays what the iOS device believes the object displayed in the camera is, whenever the screen is tapped. (See bottom of article for example pictures)

Project Setup

We begin our journey in Xcode (9 or above), where we create a new Augmented Reality App...

...give it a name... (in my case "arkit-testing-2") and set the Content Technology as SpriteKit...

...select its location on our hard drive, and start plugging away.

ViewController.swift

We're going to focus on the important pieces of code in this class, as most of it is general boilerplate.

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

    // Create a session configuration
    let configuration = ARWorldTrackingSessionConfiguration()

    // Run the view's session
    sceneView.session.run(configuration)
}

In viewWillAppear the ARWorldTrackingSessionConfiguration class is created, and then the view's session is run. You can modify the configuration if you wish, but for this tutorial we won't be playing with it.

func view(_ view: ARSKView, nodeFor anchor: ARAnchor) -> SKNode? {
    // Create and configure a node for the anchor added to the view's session.
    let labelNode = SKLabelNode(text: "👾")
    labelNode.horizontalAlignmentMode = .center
    labelNode.verticalAlignmentMode = .center
    return labelNode;
}

Inside this function, an ARSKView object is provided, along with an ARAnchor object. The ARAnchor object will be important later. Inside the function an SKLabelNode is configured and returned. This will also be important later.

Before we jump into the other important file in this boilerplate project, let's modify our viewDidLoad method so we won't encounter a bug that I encountered when creating this project.

Replace...

// Load the SKScene from 'Scene.sks'
if let scene = SKScene(fileNamed: "Scene") {
    sceneView.presentScene(scene)
}

with...

let scene = Scene(size: self.view.frame.size)
sceneView.presentScene(scene)

I'm not sure what the bug is, or why this fixes it, but it does. You can play with the original code and find alternative fixes if need-be.

Scene.swift

To begin, comment out the following code inside of touchesBegan:

// Create a transform with a translation of 0.2 meters in front of the camera
var translation = matrix_identity_float4x4
translation.columns.3.z = -0.2
let transform = simd_mul(currentFrame.camera.transform, translation)

// Add a new anchor to the session
let anchor = ARAnchor(transform: transform)
sceneView.session.add(anchor: anchor)

Yes, comment all of this out. Do not delete it, we'll come back to it later.

Vision!

Inside of the Scene.swift file, make sure you import the Vision framework before getting started:

import Vision

Now go to the Apple Developer Website's machine learning page and download the InceptionV3 model. You can download any model you'd like, this is just the one I prefer and for what it does it's relatively small in file size.

Editor's Note: The InceptionV3 model is no longer on the site. Fortunately, you can download a different model and adapt the code accordingly.

All you have to do now is drag and drop the InceptionV3 MLModel file into your project, just like you would with any other file.

What Xcode does for you here is generate a Swift interface for the model. I would recommend watching the Vision and Introducing CoreML sessions from WWDC17 to learn more about it, located here and here, respectively.

Now we're finally ready to write some code inside touchesBegan.

Let's enter a background thread to not completely wreck our application's performance when we run one of these requests (I learned this the hard way):

DispatchQueue.global(qos: .background).async {

}

Now let's create a do, catch and create a VNCoreMLModel object from our CoreML model we downloaded moments ago (depending on your internet speeds, of course)

do {            
    let model = try VNCoreMLModel(for: Inceptionv3().model)
} catch {}

Inside of our do catch and just after our model initialization, let's create a VNCoreMLRequest with a completionHandler like so:

let request = VNCoreMLRequest(model: model, completionHandler: { (request, error) in

})

Now, let's create a VNImageRequestHandler and perform our request (Write this code after VNCoreMLRequest's completionHandler):

let handler = VNImageRequestHandler(cvPixelBuffer: currentFrame.capturedImage, options: [:])
try handler.perform([request])

Let me explain what this is code actually doing, because it can get a little strange.

We're creating an image request handler to handle our request, and passing it a...

CVPixelBuffer?!? What the heck is that? According to StackOverflow, CVPixelBuffer is a part of the CoreVideo framework. Fortunately for us, we can access one from ARKit by pulling it out of the currentFrame object, saving us from doing any heavy-lifting .

currentFrame.capturedImage

Then we're performing our request with handler.perform([request]).

Now let's write the code inside of completionHandler:

// Jump onto the main thread
DispatchQueue.main.async {
    // Access the first result in the array after casting the array as a VNClassificationObservation array
    guard let results = request.results as? [VNClassificationObservation], let result = results.first else {
        print ("No results?")
        return
    }
}

Awesome, we're almost done with our Scene class. Remember the code we commented earlier? Let's paste it in after we perform that guard statement.

We're also going to modify a property to make our text appear further away from the device when we instantiate our ARKit object:

// Create a transform with a translation of 0.2 meters in front of the camera
translation.columns.3.z = -0.4 // Originally this was -0.2

If you'd like, you can update the comment to read 0.4 meters, because that comment was for the previous value of the property.

One last thing and we're done with our Scene class. Create a new swift file called ARBridge and paste the following code:

import UIKit
import ARKit

class ARBridge {

    static let shared = ARBridge()

    var anchorsToIdentifiers = [ARAnchor : String]()

}

The anchorsToIdentifiers property will allow us to associate an ARAnchor with its corresponding machine-learning value.

Let's add a value to this dictionary, and restructure our code so that it executes properly:

// Create a new ARAnchor
let anchor = ARAnchor(transform: transform)

// Set the identifier
ARBridge.shared.anchorsToIdentifiers[anchor] = result.identifier

// Add a new anchor to the session
sceneView.session.add(anchor: anchor)

Side note: If we save our identifier after we add the anchor to our scene, it won't appear properly. Make sure your code is in the order shown above.

We're all set! This is all of the code we just wrote inside of our touchesBegan function:

DispatchQueue.global(qos: .background).async {
                do {
                    let model = try VNCoreMLModel(for: Inceptionv3().model)
                    let request = VNCoreMLRequest(model: model, completionHandler: { (request, error) in
                        // Jump onto the main thread
                        DispatchQueue.main.async {
                            // Access the first result in the array after casting the array as a VNClassificationObservation array
                            guard let results = request.results as? [VNClassificationObservation], let result = results.first else {
                                print ("No results?")
                                return
                            }

                            // Create a transform with a translation of 0.4 meters in front of the camera
                            var translation = matrix_identity_float4x4
                            translation.columns.3.z = -0.4
                            let transform = simd_mul(currentFrame.camera.transform, translation)

                            // Add a new anchor to the session
                            let anchor = ARAnchor(transform: transform)

                            // Set the identifier
                            ARBridge.shared.anchorsToIdentifiers[anchor] = result.identifier

                            sceneView.session.add(anchor: anchor)
                        }
                    })

                    let handler = VNImageRequestHandler(cvPixelBuffer: currentFrame.capturedImage, options: [:])
                    try handler.perform([request])
                } catch {}
            }

(Finally) Back to ViewController.swift

The only thing we need to do now is modify our view method to retrieve the text associated with our ARAnchor, which was generated by our machine learning model.

func view(_ view: ARSKView, nodeFor anchor: ARAnchor) -> SKNode? {
    // Create and configure a node for the anchor added to the view's session.
    guard let identifier = ARBridge.shared.anchorsToIdentifiers[anchor] else {
        return nil
    }

    let labelNode = SKLabelNode(text: identifier)
    labelNode.horizontalAlignmentMode = .center
    labelNode.verticalAlignmentMode = .center
    labelNode.fontName = UIFont.boldSystemFont(ofSize: 16).fontName
    return labelNode
}

If there is no text associated with the ARAnchor, no SKNode is returned. If text exists, we create an SKLabelNode, change the font, and return it!

Testing!!!

I ran around my room pointing my camera at random objects, and this was the result:

It believed the MacBook Air on my desk was a stethoscope (that could have been the headphones or the mic), the pen on my nightstand was a revolver, and my Apple Watch sport band was a hatchet.

Other than that, it was amazing at predicting what the objects were. It thought the code for this project was a web-site, which was slightly correct. It also detected the snake pattern on my mousepad from Razer, which was pretty amazing.

With different models, I'm sure there will be different results, so try multiple models out and see what happens. It's as simple as dragging and dropping them into the project and changing the line of code that accesses the model.

The final project can be found on GitHub here, if you just want to run it and see what happens!

Thank you so much for reading, hopefully you enjoyed my (pretty basic) endeavor into ARKit and Vision!

From Storyboards to Code in iOS

Jordan Osterberg — Sun, 04 Jun 2017 01:28:49 +0000

Recently I tried something I had feared for a long time: Using code to create my views instead of using the traditional storyboard.

Background

In any given iOS programming tutorial, you will most likely use storyboards to complete your task.

Examples:

Now, there is nothing inherently wrong with using storyboards. They're perfectly fine and get the job done with creating your UI...

Right?

While the first part of my statement above is true, storyboards sometimes fall short when working in bigger projects with many view controllers or in views that have many elements and subviews.

The Problem

My largest project right now had 20-30 view controllers in a single storyboard. Whenever I would open the storyboard, my ancient MacBook Pro would struggle to load the storyboard. I needed to rapidly iterate on my views based on changes in code and having the storyboard load time be 10 seconds+ wasn't an ideal situation.

Note: I later switched to using multiple storyboards which (mostly) eliminated this issue, however having multiple storyboards with storyboard reference outlets all over each of them is really confusing.

When a view controller in a storyboard has multiple views, selecting the correct one becomes difficult if they cover each other or reside as subviews. It is possible, but it's a tedious task that I wanted to avoid.

I also wanted to try something new, and killing storyboards sounded fun.

My Solution

Code is great. And if I'm already using some code in my projects, why not go "full code"?

But wait... No storyboards = no visible view until runtime... How am I supposed to iterate quickly when I can't even see what I'm working on?!?

Ages ago, I read an article on how a fairly large app open-sourced and detailed their design iteration process. They used Swift Playgrounds to see the controller in real-time as they modified the code. Brilliant, let's do that!

Okay... so how do I use auto-layout and constraints without a storyboard? Through some research, I found out how to use constraints inside code.

Swift 3 Example:

let view = UIView() // Create view object
view.translatesAutoresizingMaskIntoConstraints = false // Set this to false so this works as expected
view.backgroundColor = UIColor.red // Let's set this to red so we can see where our view is in our controller
self.view.addSubview(view) // Add our view to the view controller's view
// View created, constraint time:
view.heightAnchor.constraint(equalToConstant: 50).isActive = true
// Let's break this down.
// view.heightAnchor will set our view's height, as the name implies.
// constraint(equalToConstant: 50) Will set the value to an integer constant of 50
// isActive = true will activate our constraint
// Simple! Let's do the rest of the constraints:
view.widthAnchor.constraint(equalTo: self.view.widthAnchor, multiplier: 1/2).isActive = true // Set our width to be 1/2 of the view's size
view.centerXAnchor.constraint(equalTo: self.view.centerXAnchor).isActive = true // Center horizontally on the X axis
view.centerYAnchor.constraint(equalTo: self.view.centerYAnchor).isActive = true // Center vertically on the Y axis
// And... done!

Let's take a look at our playground:
http://i.imgur.com/IRSyJLb.png

Awesome! Let's play around with these constraints and make our view appear at the top of the controller.

let view = UIView()
view.translatesAutoresizingMaskIntoConstraints = false
view.backgroundColor = UIColor.red
self.view.addSubview(view)

view.heightAnchor.constraint(equalTo: self.view.heightAnchor, multiplier: 1/3).isActive = true
view.widthAnchor.constraint(equalTo: self.view.widthAnchor).isActive = true
view.centerXAnchor.constraint(equalTo: self.view.centerXAnchor).isActive = true
view.topAnchor.constraint(equalTo: self.view.topAnchor).isActive = true

Here I've used a new item: topAnchor

Setting it equal to the view controller's view's topAnchor (that's a mouthful!) will cause our view to reside at the top of the view controller's view.

I've also set our width to be equal to the view's width, centered our view horizontally, and set our height to be 1/3 of the parent view's height.

Let's see what this did to our view:

So cool! In just a few lines of code, we've created a view at the top of our view controller.

To learn more on how to use these constraints, I decided to take an existing view controller created in my storyboard and re-create it in code.

I actually ended up creating a simple view controller/tool called "AccountController" that can be easily modified to show a login and registration page. Neat!

Here's a GitHub link for anyone who wants to try it out.

Also, feel free to modify it as you wish, it's under the MIT license! I plan on fixing some issues and improving on it over time, but feel free to fix bugs and improve it for me via pull request!

Thanks for reading!

FYI, I'm only 15 (almost 16!) so if my grammar or wording is poor, I apologize :)

DEV Community: Jordan Osterberg

Realm Database Guide - Building a Note app in Swift for iOS

Table of Contents

Introduction

Installing Dependencies

The Model

Implementing Realm

Creating the Realm Object

Bridging between our Realm object and our primitive Note object

Begin retrieving and modifying data with Realm

Conclusion

"You've won a WWDC18 Scholarship."

Dear Jordan Osterberg,

4/20/18

Accessibility in your software | iOS & VoiceOver

From Storyboards to Code in iOS (Episode II)

Recap

Problems with the Solution

Solutions for the Problems with the Solution

ARKit + Vision: An intriguing combination

What are we doing?

Project Setup

ViewController.swift

Scene.swift

Vision!

(Finally) Back to ViewController.swift

Testing!!!

From Storyboards to Code in iOS

Background

The Problem

My Solution