☞ Next week is about unarchiving SPT.

None of my old Safari web archives from a few years ago will open any more.

Wordle 523 1/6

🟩🟩🟩🟩🟩

☞ Next week is about making it click.

A few weeks ago I finished Paul Hudson’s excellent 100 Days of SwiftUI course. The next step in getting hired as a developer and/or building an indie developer business while continuing to develop my skills is to start building an app or two.

Since I’m currently trying to lose some weight (so I can fit back into some really nice bespoke-tailored shirts that I’ve, ahem, outgrown), and I’ve only ever succeeded at that in the past via old-school calorie counting, I decided my first project would be an app I can use to log my weight against my food intake. I call it MetaboLog.

Motivation

Besides calories, I want to be able to track macronutrients (protein, fat, and carbohydrates) as well as, optionally, micronutrients such as vitamins and minerals. To minimize friction, I also want the flexibility to be able both to log known meals with a click and to analyze previously unrecorded dishes from their ingredients.

I’ll be drawing the detailed nutritional data from the U.S. Department of Agriculture’s FoodData Central database. The data structure from its API — multiple APIs, actually — is quite a bit more complex than anything in a coding tutorial, but I suppose that’s the game I signed up to play.

As of right now I’m at a loss why the JSONDecoder can parse “lowercaseDescription”:“cheddar cheese” just fine, but fails to parse “servingSizeUnit”:“g” within the same chunk of JSON.

Update: the “servingSizeUnit” attribute doesn’t exist for every element in the JSON dataset, so it has to be decoded as an optional String? rather than a plain String. Ahhhhbviously!

In Big Bend Ranch State Park last week

For now at least, weekends (and holidays) are the only times I really have the opportunity to focus on code for more than an hour or two at a time, so if I want to complete the more difficult “challenges” in 100 Days of SwiftUI or other courses, that’s when I’ll have to work on them. That means setting aside work on my own app(s) any time I reach a course challenge that I can’t get past in a couple of hours. Since (at least at my skill level, and maybe at all) there’s no reliable way of estimating how long it will take to reach a stopping point in my independent work, I can’t really do it the other way around. So I’m setting aside MinderBoard and turning back to 100 Days of Swift, which I’d like to finally finish within the next few weeks.

I’m actually focused on UIViewControllerRepresentable right now in both MinderBoard and the 100 Days challenge anyway.

Nick Sarno’s Use UIViewControllerRepresentable to convert UIKit controllers to SwiftUI video on YouTube and Paul Hudson’s series starting with Wrapping a UIViewController in a SwiftUI view cover very similar territory. Without digging through Apple’s documentation, the UIImagePickerController type in Nick’s video and the PHPickerViewController in Paul’s seem to do (exactly?) the same thing.

The code in the two tutorials is also very similar, with a few notable exceptions. Rather than replicating the view controller struct’s @Binding variables inside the Coordinator class, Paul creates a reference to the view controller as the Coordinator’s parent, allowing us to access its properties. This seems like a much more elegant approach. Using the view controller’s .dismiss() method also feels cleaner than passing showScreen around as a binding.

By defining the @State image variable in his main SwiftUI ContentView as an (optional) UIImage? rather than an (optional) SwiftUI Image? in the first place, on the other hand, Nick has no need of Paul’s additional @State inputImage variable, loadImage() function, and .onChange() modifier.

Paul’s beautiful dogs make an appearance in his videos, so that’s points for him. Advantage, Paul Hudson.

For Paul’s Challenge I do need to detect when a new photo is added, so I’ll actually still need the .onChange modifier. But it’s getting to be dinner time, so I’ll continue tomorrow.

Why do Markdown unordered lists in my micro.blog posts look fine in the Mac app preview but display as unbroken paragraphs in Safari?

Still working on getting my head wrapped around UIViewRepresentable and UIViewControllerRepresentable. A pair of YouTube videos from Nick Sarno (Swiftful Thinking) is offers a helpful different perspective from Paul Hudson’s material that I’ve mostly been following.

Not sure I quite get the concept of “context”.

Elements of a UIViewRepresentable struct:

• @Binding var — data being passed between the representable UIView and the parent SwiftUI view
  
• Coordinator class and func makeCoordinator() -> Coordinator
  
• func makeUIView(context: Context) -> some UIView
  
• func updateUIView(_ uiView: UIViewType, context: Context)
  

Open questions:

• ¿Does every UIView and UIViewController subclass have its own delegate protocol?
• ¿What’s the self._text thing about?

Excellent explanation by @twostraws of using UIViewControllerRepresentable and Coordinator to incorporate UIKit elements into a SwiftUI app. A complex topic clearly laid out. www.hackingwithswift.com/books/ios…

Just like it says in the title, Peter Friese’s Building a To-Do List App with SwiftUI, Combine, and Firebase calls for a dive into Combine, which I haven’t studied yet.

Seems like something I’m going to have to learn sooner or later, though. Fortunately I bought Daniel Steinberg’s A Combine Kickstart on Black Friday.

The question now is whether I want to take a 500+ -page detour before making something, when the plan for weekend coding was supposed to be to get away from tutorials and see what I can do on my own. Since I’ll be pushing and pulling data from outside my app, I’ll presumably want to use some kind of async code, but maybe I should try the new Swift async/await first instead? In which case, given that I’m not interested in using Firebase for this project either, Friese’s project may end up not being all that useful.

I’m not getting very far with just the Apple developer documentation for EventKit, so let’s see what else is out there…

Friese’s Task model:

enum TaskPriority {
  case high
  case medium
  case low
}

struct Task: Identifiable {
  var id: String = UUID().uuidString
  var title: String
  var priority: TaskPriority
  var completed: Bool
}

By contrast, Apple’s native EKReminder is a class that inherits from EKCalendarItem, which in turn inherits from EKObject. Its accessible properties:

• EKReminderPriority (an enum with values none, high, medium, and low)
• priority: Int
• startDateComponents: DateComponents?
• dueDateComponents: DateComponents?
• isCompleted: Bool
• completionDate: Date?

And accessible properties inherited from EKCalendarItem:

• calendarItemIdentifier: String
• calendarItemExternalIdentifier: String! — external identifier as provided by the calendar server
• calendar: EKCalendar!
• title: String!
• location: String?
• creationDate: Date?
• lastModifiedDate: Date?
• timeZone: TimeZone?
• url: URL?
• hasNotes: Bool
• notes: String?
• hasAttendees: Bool — so a reminder can have attendees?
• attendees: [EKParticipant]?
• hasAlarms: Bool
• alarms: [EKAlarm]?
• hasRecurrenceRules: Bool
• recurrenceRules: [EKRecurrenceRule]?

The EKObject class’s properties, booleans hasChanges and isNew, relate to saving and restoring state.

¿Why two different priority properties?
¿Why simply completionDate and not completionDateComponents?

Not following a tutorial today, just going to see if I can wrangle control of EventKit.

On weekends I’m trying to get away from tutorials per se, although at this point in my developer journey I’ll still be stealing adapting a lot of other people’s code. I’ll do my best to credit anyone whose code I cite here on the blog, and of course I’ll observe licenses when it comes to publishing anything.

I’m interested in working with EventKit, Apple’s framework for accessing calendar and reminders data. Specifically, I want to build an app that works with reminders. So far I haven’t found much any sample code online that uses EventKit in a SwiftUI environment; Apple’s Calendars and Reminders Programming Guide doesn’t even use Swift but rather Objective-C. (If he sees this @chrislowiec will be saying “I told you so!”)

I’m going to try starting with Peter Friese’s Building a To-Do List App with SwiftUI, Combine, and Firebase, which seeks to replicate the built-in iOS Reminders app, but instead of rolling a clone of the system’s underlying Reminders data store in Firebase I’ll be connecting to the original one. Once the basic create/delete/edit functionality is in place I have some ideas for different ways to view and manipulate tasks that I think could be useful for myself and others. Oh, and I’ll be writing mine for macOS and possibly iPadOS, because I think the iPhone screen is going to be too cramped for what I have in mind.

Since I’m going to be switching out bits and pieces derived from sample code from different sources, I’m making this as modular as I can, with a separate file for each view. Other than that, a #if statement for the .navigationBarTitle modifier that’s not available for macOS, and a few naming changes to make it easier to replace various elements of Friese’s code later, I haven’t yet written anything today that’s not taken directly from there, so there’s not much point in posting any of the code here.

Not sure if I’ll return to this before next weekend. Tomorrow I’m going to pick up where I left off in Paul Hudson’s 100 Days of SwiftUI.

Alternative Christmas movies for people who hate holiday sentimentality:

1. OK, I’ll give you Die Hard!

2. Bad Santa

3. Eyes Wide Shut

4. … other suggestions?

macOS custom menu command

https://developer.apple.com/tutorials/swiftui/creating-a-macos-app

“The pattern for defining focused values resembles the pattern for definining new Environment values: Use a private key to read and write a custom property on the system-defined FocusedValues structure.”

“definining” lol

I am lost. Time to read the Swift language reference?

private struct SelectedLandmarkKey: FocusedValueKey {
    typealias Value = Binding<Landmark>
}

extension FocusedValues {
    var selectedLandmark: Binding<Landmark>? {
        get { self[SelectedLandmarkKey.self] }
        set { self[SelectedLandmarkKey.self] = newValue }
    }
}

FocusedValues is a struct type defined in the SwiftUI framework, a “collection of state exported by the focused view and its ancestors”.

So, within the app, ¿FocusedValues knows if a given Landmark is selected/has focus?

• [ ] Find a thorough explanation of the <AngleBrackets> syntax

• [ ] And ¿what the heck is self[SelectedLandmarkKey.self]?

• [ ] Also find documentation for SwiftUI .tag(x) modifier

• SelectedLandmarkKey is a struct that I just defined.

• So SelectedLandmarkKey.self is… a reference to that struct type?

• And, in the extension, the first self is a reference to (an instance of?) FocusedValues

• [ ] But FocusedValues is a struct, not an array or a dictionary, so ¿how does the square brackets syntax work with structs?

Apple tutorial: Interfacing with UIKit

Completely lost on this coordinator stuff.

import SwiftUI
import UIKit

struct PageViewController<Page: View>: UIViewControllerRepresentable {
    var pages: [Page]
    
    func makeCoordinator() -> Coordinator {
        Coordinator(self)
    }
    
    func makeUIViewController(context: Context) -> UIPageViewController {
        let pageViewController = UIPageViewController(
            transitionStyle: .scroll,
            navigationOrientation: .horizontal
        )
        pageViewController.dataSource = context.coordinator
        
        return pageViewController
    }
    
    func updateUIViewController(_ pageViewController: UIPageViewController, context: Context) {
        pageViewController.setViewControllers([context.coordinator.controllers[0]], direction: .forward, animated: true)
    }
    
    class Coordinator: NSObject, UIPageViewControllerDataSource {
        var parent: PageViewController
        var controllers = [UIViewController]()
        
        init(_ pageViewController: PageViewController) {
            parent = pageViewController
            controllers = parent.pages.map { UIHostingController(rootView: $0) }
        }
        
        func pageViewController(
                _ pageViewController: UIPageViewController,
                viewControllerBefore viewController: UIViewController
            ) -> UIViewController? {
            guard let index = controllers.firstIndex(of: viewController) else {
                return nil
            }
            if index == 0 {
                return controllers.last
            }
            return controllers[index - 1]
        }
        
        func pageViewController(
            _ pageViewController: UIPageViewController,
            viewControllerAfter viewController: UIViewController
        ) -> UIViewController? {
            guard let index = controllers.firstIndex(of: viewController) else {
                return nil
            }
            if index + 1 == controllers.count {
                return controllers.first
            }
            return controllers[index + 1]
        }
    }
}

What do y’all think: update MailSuite and stick with Mail.app for another year, or drop a few extra bucks and jump ship to @MailMateApp?

Yes, even on Thanksgiving. (I suppose I should write something about how grateful I am to have the wherewithal to learn code, etc., and honestly I am, but I’m allergic to the orchestrated sentimentality that accompanies the fall and winter holidays.)

CaseIterable

/// A type that provides a collection of all of its values.
///
/// Types that conform to the `CaseIterable` protocol are typically
/// enumerations without associated values. When using a `CaseIterable` type,
/// you can access a collection of all of the type's cases by using the type's
/// `allCases` property.
///
/// The compiler can automatically provide an implementation of the
/// `CaseIterable` requirements for any enumeration without associated values
/// or `@available` attributes on its cases. The synthesized `allCases`
/// collection provides the cases in order of their declaration.

Dictionary of arrays

var categories: [String: [Landmark]] {
        Dictionary(
            grouping: landmarks,
            by: { $0.category.rawValue }
        )
    }

• Look at features of Swift Dictionary type

Still in the Apple SwiftUI tutorial.

I don’t like that the tutorial is having me drag in downloaded view files rather than writing them myself. Even if the code consists of techniques that have already been covered, I’m not a grizzled veteran who’s been coding Swift everyday for years, and the reinforcement would have been useful. I mean, I guess I could retype it from the downloaded source files…

Should I track down the source of the “snag” or just go on with the tutorial? I don’t really see myself drawing a lot of paths in my own apps, and I haven’t coded since starting my new (non-technical, alas) job, so I’d like to get on with the stuff I’m more interested in mastering.

I started the Apple SwiftUI tutorial as a break from Paul Hudson’s brilliant 100 Days of SwiftUI because the former includes a macOS lesson… but it’s preceded by quite a bit of iOS-centric material, and I still haven’t gotten to the Mac stuff.

The accompanying text of the tutorial (not the code itself, of course), always uses the full word ‘structure’, never just ‘struct’.

¿OK, what does Hashable do again, precisely?

Other than manually disabling and later reenabling cross-posting, is there a way to post to micro.blog without cross-posting on a per-post basis?

Back to (micro-) blogging, in the spirit of Andy Matuschak’s concept of “Working with the garage door open”. Time will tell how long I stick with it this time around and how often I actually post.

Mission San Jose, San Antonio, 2020-12-25