Programming Log: 2022

Saturday, December 10, 2022

WWDC 2022 Video Sessions

Last June, Apple hosted WWDC 2022 at its headquarters. Video sessions, from June 7 to 10, are available at the Apple developer site. As usual, I watched those videos in the past few months. Now I've finished watching all of them.

The following are videos I watched.

Monday

Apple Design Awards
Keynote
Platforms State of the Union
WWDC22 Day 1 recap

Tuesday

Add accessibility to your Unity games
Adopt Variable Color in SF Symbols
Adopt desktop-class editing interactions
Bring Continuity Camera to your macOS app
Bring your driver to iPad with DriverKit
Bring your world into augmented reality
Build your first app in Swift Playgrounds
Capture machine-readable codes and text with VisionKit
Complications and widgets: Reloaded
Create a more responsive media app
Create macOS or Linux virtual machines
Create parametric 3D room scans with RoomPlan
Deliver reliable streams with HLS Content Steering
Discover Metal 3
Dive into App Intents
Enhance collaboration experiences with Messages
Explore more content with MusicKit
Get more mileage out of your app with CarPlay
Get the most out of Xcode Cloud
Get timely alerts from Bluetooth devices on watchOS
Get to know Create ML Components
Get to know Developer Mode
Hello Swift Charts
Implement App Shortcuts with App Intents
Load resources faster with Metal 3
Meet Apple Maps Server APIs
Meet Focus filters
Meet Swift Async Algorithms
Meet Swift Regex
Meet WeatherKit
Meet Web Push for Safari
Meet desktop-class iPad
Meet passkeys
Plug-in and play: Add Apple frameworks to your Unity game projects
Program Metal in C++ with metal-cpp
Qualities of great AR experiences
The SwiftUI cookbook for navigation
Visualize and optimize Swift concurrency
Day 2 recap
What's new in App Clips
What's new in AppKit
What's new in Create ML
What's new in Nearby Interaction
What's new in SF Symbols 4
What's new in Safari and WebKit
What's new in SharePlay
What's new in Swift
What's new in SwiftUI
What's new in UIKit
What's new in Xcode
What's new in managing Apple devices
What's new with in-app purchase
What’s new in notarization for Mac apps

Wednesday

Add Live Text interaction to your app
Add Shared with You to your app
Adopt declarative device management
Boost performance with MetalFX Upscaling
Bring your iOS app to the Mac
Build a desktop-class iPad app
Build a productivity app for Apple Watch
Build global apps: Localization by example
Compose advanced models with Create ML Components
Compose custom layouts with SwiftUI
Create engaging content for Swift Playgrounds
Create your Privacy Nutrition Label
Design App Shortcuts
Design an effective chart
Design app experiences with charts
Discover advancements in iOS camera capture: Depth, focus, and multitasking
Display ads and interstitials in SharePlay
Eliminate data races using Swift Concurrency
Embrace Swift generics
Explore EDR on iOS
Explore in-app purchase integration and migration
Improve the discoverability of your Swift-DocC content
Integrate your custom collaboration app with Messages
Link fast: Improve build and launch times
Meet Apple Music API and MusicKit
Meet Background Assets
Meet CKTool JS
Meet ScreenCaptureKit
Meet Transferable
Meet distributed actors in Swift
Meet the expanded San Francisco font family
Optimize your Core ML usage
Optimize your use of Core Data and CloudKit
Replace CAPTCHAs with Private Access Tokens
Streamline local authorization flows
Support multiple users in tvOS apps
Swift Regex: Beyond the basics
Take ScreenCaptureKit to the next level
Target and optimize GPU binaries with Metal 3
Understand USD fundamentals
Use Xcode to develop a multiplatform app
WWDC22 Day 3 recap
What's new in HealthKit
What's new in Swift-DocC
What's new with SKAdNetwork
What’s new in AVQT
What’s new in CloudKit Console
What’s new in Endpoint Security
What’s new in Safari Web Extensions
What’s new in Wallet and Apple Pay
What’s new in iPad app design
What’s new in privacy

Thursday

Create Safari Web Inspector Extensions
Create Safari Web Inspector Extensions
Create a great video playback experience
Create camera extensions with Core Media IO
Debug Swift debugging with LLDB
Deep dive into Xcode Cloud for teams
Demystify parallelization in Xcode builds
Design for Arabic
Design for Collaboration with Messages
Design protocol interfaces in Swift
Discover ARKit 6
Discover PhotoKit change history
Discover Sign in with Apple at Work & School
Display EDR content with Core Image, Metal, and SwiftUI
Display HDR video in EDR with AVFoundation and Metal
Enhance your Sign in with Apple experience
Evolve your Core Data schema
Explore App Tracking Transparency
Explore Apple Business Essentials
Get it right(to left)
Go bindless with Metal 3
Go further with Complications in WidgetKit
Improve app size and runtime performance
Make a great SharePlay experience
Maximize your Metal ray tracing performance
Meet Swift Package plugins
Reach new players with Game Center dashboard
Reduce networking delays for a more responsive app
Simplify C++ templates with concepts
SwiftUI on iPad: Add toolbars, titles, and more
SwiftUI on iPad: Organize your interface
The craft of SwiftUI API design: Progressive disclosure
Track down hangs with Xcode and on-device detection
Transform your geometry with Metal mesh shaders
Use SwiftUI with AppKit
Use SwiftUI with UIKit
WWDC22 Day 4 recap
What's new in App Store Connect
What's new in MapKit
What's new in StoreKit testing
What's new in TextKit and text views
What's new in Vision
What's new in the Photos picker
What's new in web accessibility
What’s new in HLS Interstitials
Writing for interfaces

Friday

Accelerate machine learning with Metal
Author fast and reliable tests for Xcode Cloud
Bring multiple windows to your SwiftUI app
Build device-to-device interactions with Network Framework
Create Swift Package plugins
Create accessible Single App Mode experiences
Create custom catalogs at scale with ShazamKit
Discover Benchmarks in App Analytics
Discover Managed Device Attestation
Efficiency awaits: Background tasks in SwiftUI
Explore SMS message filters
Explore media metadata publishing and playback interactions
Explore the machine learning development experience
Implement proactive in-app purchase restore
Improve DNS security for apps and servers
Power down: Improve battery consumption
Profile and optimize your game's memory
Scale compute workloads across Apple GPUs
Use Xcode for server-side development
WWDC22 Day 5 recap
What's new in PDFKit
What's new in Screen Time API
What's new in WKWebView

References

WWDC 2022 Vedio sessions

Saturday, September 03, 2022

Unselect cell in tableview if the cell is visible

I have an iOS app. The main screen has a tabbar on the bottom with three tab bar items. Here I'll explain two related tabs. One of them, the “export” tab, is for displaying objects in a tableview. It allows the user to make multiple selections. Another one, the "edit" tab, is for editing objects. If a user makes any changes to objects, any previously selected object items in the export tab will be cleared if the user switches back to the export tab.

Multiple Selection in Export View

In order to keep selected objects consistant, I created a class called SelcHelper to catch selected objects' indexPath. In ExportViewController, there is a function selectRow which is used to select or deselect a row in the table view.


class ExportViewController:
  BaseTableViewController // this is my base class on UITableViewController
{
  private var selHelp[er = SelHelper()
  private func selectRow(
    select: Bool,
    tableView: UITableView,
    at indexPath: IndexPath)
  {
    if select {
      tableView.selectRow(
        at: indexPath,
        animated: true,
        scrollPosition: .none)
      } else {
        tableView.deselectRow(
          at: indexPath,
          animated: true)
      }
  }
  ...
}

Here is how I implement multiple selection in tableview events:


class ExportViewController:
  BaseTableViewController // this is my base class on UITableViewController
{
  ...
  func tableView(
    _ tableView: UITableView,
    didDeselectRowAt indexPath: IndexPath)
  {
    selHelper.remove(indexPath: indexPath)
    tableView.reloadRows(at: [indexPath], with: .none)
  }
  ...
  func tableView(
    _ tableView: UITableView,
    didSelectRowAt indexPath: IndexPath)
  {
    selHelper.add(indexPath: indexPath)
    tableView.reloadRows(at: [indexPath], with: .none)
  }
  func tableView(
    _ tableView: UITableView,
    cellForRowAt indexPath: IndexPath)
    -> UITableViewCell // cellForRow event
  {
    let cell = tableView.dequeueReusableCell(
          withIdentifier: "cell")
    ...
    let isSelected =  selHelper.isIndexPathSelected(indexPath)
    cell.isSelected = isSelected
    selectRow(
      select: isSelected,
      tableView: tableView,
      at: indexPath)
    return cell
}

The above codes work perfectly for multiple selections.

Users may edit objects in the "edit" tab view after they make some selections in the "export" view. As mentioned above, in the case of any objects changed, I want to clear all the selections in the "export" tab view. The following codes are added in the event of viewWillAppear to clear all the catched indexPath values.


class ExportViewController:
  BaseTableViewController // this is my base class on UITableViewController
{
  override open func viewWillAppear(
    _ animated: Bool)
  {
    super.viewWillAppear(animated)
    ...
    if myDBModel.dataChanged
    {
      selHelper.clear() // clear all indexPath
    }
  }
  ...
}

The logic is very clear. In the event of viewWillAppear, if the datasource has any changes, I'll clear all the catched selection indexPath values. This clearance will guarantee the cellForRow call to set cells unselected. Since I use a core data source for my export tableview, the cells with objects changed and in the visible area will be called to reload the cell.

Problem for visible cells

However I found a problem. If the visible cells in the tableView have any selections, the selection marks are gone. I verified that the cellForRow event was called after the event of viewWillAppear and all the selected cells are set to unselected. There is a problem: the cells are still in a high-light status. This status causes the cell to not be selected or unselected again!

For example, here is a cell is selected:

I changed the datasource first, and then back to the export tabview. The viewWillAppear event is called and all selections are set to deselected. The visible cell looks like this: the selection check mark is gone, but it looks like it is still highlighted and cannot be selected again.

I could scroll the tableView to move those visible cells to an un-visible area and scroll back. They are back to their normal status: unselected and not hilighted. However, what if there are only a small number of objects and they cannot be moved out of the tableView? The user would be stuck with this frastration situation and not be able to make a selection again. The user has to kill the app and restart the app to get back to normal.

Found a Soltion!

I think that this situation might be a problem or bug in UIKit. I have been struggling to find a way to resolve the issue for days. After several days and various attempts, suddenly, one evening very late, I found a solution to resolve the issue!

The solution is actually very simple. What I need to do is to call my private function selectRow to clear all selection for the visible cells in the event of viewWillDisappear! This clearance is OK. If there were no data changes, the cellForRow would not be called. If there is any data change, the cached selection indexPath values are cleared in the event of viewWillAppear first, and then cellForRow will be called to deselect visible cells.


class ExportViewController:
  BaseTableViewController // this is my base class on UITableViewController
{
  ...
  override func viewWillDisappear(_ animated: Bool)
  {
    super.viewWillDisappear(animated)
    guard let ips = tableViewInBase.indexPathsForSelectedRows
      else { return }
    // deselect all select rows in tableview on exit
    // this will guaranty selection works again on
    // appearance!
    for ip in ips {
      selectRow(select: false,
        tableView: tableViewInBase,
        at: ip)
      }
    }
  ...
}

References

My question posted on SO: unselect cell in tableview if the cell is visible
My iOS App: TapMyNotes

Friday, August 19, 2022

iOS Core Data Database Update

The Core Data database is the most commonly used as a data store for iOS apps. Nobody could design the database once and never change it again. I occasionally need to make some changes or update my Core Data database.

When the database scheme is changed, for example, adding a new entity, removing an entity, or changing entity fields, how could such kinds of changes affect your app? Would your app users lose all the data if any changes are made?

If you don't set up your database correctly, you may cause users frustration or pain. Fortunately, Apple provides a very solid and complete core data framework to allow you to migrate database changes during your app's life time without losing any data. In most cases, you would not need to do anything in particular. In some cases, you may need to write some codes to update data since you know what should be done.

Here are some notes regarding this issue.

Set the Correct Core Data Store Options

For the time being, in iOS 10.*, a Core Data store is created and managed by means of NSPersistentContainer. At the time this container is created, some critical options have to be set so that future updates or changes will be migrated smoothly without losing data.

The following is an example of how to set up the container with important options. If you don't set those, any changes to the database store would cause data loss because of a totally new schema.


let storeDesription = NSPersistentStoreDescription(url: url)
storeDesription.shouldInferMappingModelAutomatically = true
storeDesription.shouldMigrateStoreAutomatically = true
container.persistentStoreDescriptions = [storeDesription]
container.loadPersistentStores() {
    (storeDescription, error) in
    if let error = error as NSError? {
        // Handle errors here
    }
}

Add a New Version of the Database

In Xcode 9.4, if you need to change your database schema, don't make the change directly to the database model. Instead, add a new version to your database model and make the new version the active model.

From the menu of Editor->Add Model Version...,

Accepting the recommended model name, a new model version will be added.

In the right-hand inspector, add a new model identifier and select the new version as the current model version.

In this way, you can carry the previous database schema as-it-is to the next new version and make changes to the new version.

In most cases, all your data will be kept in the new database without any loss. Even though you have to test your app after your update to make sure it will keep or present previous database data smoothly.

Add Your Customized Updates

If you need to update your data as you know what the changes are and how to set up data correctly, you can do it at your app startup time.

For example, here is my practice of updating data at the app delegate class:


@UIApplicationMain
class AppDelegate : UIResponder, UIApplicationDelegate {
  func application(_ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool
    {
       // Override point for customization after application launch.
       MyUserDefaults.shared.setupDefaults()
       AppDatabase.shared.updateDatabase()
       return true
    }
...
}

I use UserDefaults, i.e., app settings, as a place to save app and database versions and load those versions at the app's startup time. Then in the updateDatabase() method, I'll check if the previous app and database versions are older than a given version. If so, then some updates will be made so that the data will be kept up to date. Here is my example case:


class AppDatabase {
  static var shared: AppDatabase {
    struct local {
      static let instance = AppDatabase()
    }
    return local.instance
  }

  func updateDatabase() {
     guard VersionManager.shared.isOlderThan(.database_v1_2_0) else { return }
     cleanUpDataBase()      // do some cleanup missed in old db
     updateSortProperties() // set sort values for the new fields
  }
  ...
}

References

Apple Developer Documentation: Using Lightweight Migration

Friday, August 12, 2022

Building a Bridge between Swift and JS

This was a challenge for me to make Swift talk to JS or JS to Swift. I have been working on an iOS app for years. With so many years of practice, I think I am very good at a deep technical level. I have also done a lot of html and JS programming. What I know about JS is mainly based on what I need to do on my blog.

In my app updates, what I need to do is to provide some information to users about how to use the app. An HTML view is a good choice for this purpose. However, I encountered a challenge that some of the information HTML needs is actually available easily on the Swift side. How can I let JS make a request to Swift, and then Swift pass the requested information back to JS?

This is what I mean by a bridge between Swift and JS.

Working Environment

In my project, I use a simple ViewController with a WKWebView UI component. The class is a very simple one. In the viewDidLoad event, an html file will be loaded into WKWebView. The content defined in the html file will be displayed on the view screen.


class MyWebViewController: UIViewController
{
   @IBOutlet weak var webView: WKWebView!
   {
     didSet {
       setup() // Place 1: magic will be injected from here.
     }
   }
   var htmlUrl: URL? = nil
   override func viewDidLoad()
   {
      super.viewDidLoad()
      guard let url = htmlUrl else { return }
      webView.loadFileURL(
            url
            allowingReadAccessTo: url)
      let request = URLRequest(url: url)
      webView.load(request)
   }
    override func viewWillDisappear(_ animated: Bool)
    {
        super.viewWillDisappear(animated)
        // Place 2: some codes to be added here.
    }
}

My html file contains information about how JS is loaded. Normally, a JS script file is defined in the head section. For example,


<head>
   <meta charset='UTF-8'/>
   <!-- JS functions used in html  -->
   <script type="text/javascript" src="../myScriptFile.js"></script>
   ...
</head>

As you can see from the above structure, I have a view controller with a web viewer, in Swift code to present html content. The JS files which will be referenced from html are in my project bundle. This is my working environment.

A Case Study

Here is my case. In my html content, there is one element for displaying my app version.


<h2 class="center">Version <span id="appVersion">to be filed</span></h2>

This could be easily done by using a JS function like this:


function swift2JSCallFor(appVersion) {
    let e = document.getElementById("appVersion");
    e.innerHTML = appVersion;
}

The version string can be easily obtained in Swift code. How can I make a call from Swift to this JS function with version information?

`WKScriptMessageHandler` as a Gateway

Fortunately, Apple provides an API for the case of my view controller with WKWebView. WKScriptMessageHandler is the name of this API. This handler protocol can be implemented as a message channel gateway between Swift and JS.

This gateway could be implemented in my view controller class. There are some codes required to set it up. The disadvantage of doing this in my view controller is that I would have to repeat a block of similar code again and again in other view controller classes if I needed to do a similar thing. Another point is that adding some codes just for this kind of gateway would pollute my view controller class and make it harder to read and maintain.

Build My Gateway Class

After my thorough study and tests of this framework and a good understanding of what is required, I decided to create a new class to encapsulate the business logic or structure outline inside my class and expose the necessary settings for customizing.


import WebKit
typealias ScriptMessageHandlerBlock =
    ((WKUserContentController,
      WKScriptMessage) -> ())
class MyWKScriptBridgeHelper: NSObject
{
    init(
        observer: String,
        scriptMessageHandlerBlock: ScriptMessageHandlerBlock?
    )
    {
        webObserver = observer
        wKScriptMessageHandlerBlock = scriptMessageHandlerBlock
    }
    private var webObserver: String = ""
    private var wKScriptMessageHandlerBlock:
    ScriptMessageHandlerBlock? = nil
    var webObserverName: String {
        return webObserver
    }
}
extension WKScriptMessageHandler: WKScriptMessageHandler
{
    func userContentController(
        _ userContentController: WKUserContentController,
        didReceive message: WKScriptMessage)
    {
        guard let block = wKScriptMessageHandlerBlock else
        {
            return
        }
        block(userContentController, message)
    }
}

The class logic is simple. Only two parameters are required to create an instance of this class. One is a webObserver name, which will be called from JS to Swift to the gateway implemented in this class. Another one is a block of code where Swift information will be gethered or prepared and JS functions will be called.

Set it up on the Swift Side

OK, so far so good. It is time to put it all together in practice!

In my view controller class, there are two places where I will put some code. The first place is to set up my gateway instance of the MyWKScriptBridgeHelper class.


class MyViewController
{
  private var scriptHelper: MyWKScriptBridgeHelper!
    ...
  private func setup()
  {
    let webObserver = "appVersion"
    let block: ScriptMessageHandlerBlock
        = {
            [weak self] (userController, message) in
            guard let this = self else {
                return
            }
            // Make sure that it is html js function callback
            guard message.name ==
                    webObserver else {
                return
            }
            // get app version string
            let v = ... // get app version
            let jsFunc = String(
                format: "swift2JSCallFor('%@')",
                v)
            // Sends back app version to hml js function
            this.webView.evaluateJavaScript(
                jsFunc,
                completionHandler: nil)
        }
        scriptHelper = MyWKScriptBridgeHelper(
            observer: webObserver,
            scriptMessageHandlerBlock: block)
  }
  ...
}

In this setup(), two parameters are prepared for creating the instance of MyWKScriptBridgeHelper. One is the name of "webObserver" as the message name of the gateway. Another one is the block to verify the right message is received, to prepare the app version, and finally call a JS function "swift2JSCallFor()" to send the app version to the JS side.

The second location is in the view controller disappear event, where you should perform some cleaning by removing any message handlers and deallocating scriptHelper to avoid memory leaks.


override func viewWillDisappear(_ animated: Bool)
{
   super.viewWillDisappear(animated)
   guard let sh = scriptHelper else { return }
   // Clear message handler from script helper
   webView.configuration.userContentController.removeScriptMessageHandler(
       forName: sh.webObserverName)
   scriptHelper = nil
}

That's all I need to do to set my gateway up. First, the gateway will handle a message requesting the app version from the JS side. Then it will call a JS function to pass the app version to JS.

HTML and JS Configuration

On the html and JS side, the first step is to make a request to Swift for the app version. This can be done by calling a JS function on html body element's onload attribute.


<body onload="updateVersion()">
...
<h2 class="center">Version 
<span id="appVersion">to be updated...</span></h2>
...
</body>

The second step is to set up Javascript functions to make a request and to handle Swift calls.


function updateVersion()
{
  try {
    var msg = {}; // for empty parameter, it has to be {}
    // "appVersion" is the request message name on Swift side
    window.webkit.messageHandlers.appVersion.postMessage(msg);
  } catch(err) {}
}
// function to be called from Swift to pass app version
// to JS.
function swift2JSCallFor(appVersion) {
  let e = document.getElementById("appVersion");
  e.innerHTML = appVersion;
}

The comment description in the Javascript explains everything. That's all. With the above configuration, Swift and JS can talk to each other and pass the required information as needed.

Here is a snapshot of my html view with the correct version updated. I am so happy that this update will be automatically done and I don't need to touch the html file in future updates.

I have a short summary at the conclusion of this blog. Swift-JS communication was new to me. I spent more than one week investigating and doing my tests. The above strategy is based on other resources (see references) and my effort. This is not the best and complete solution. I may miss something. Please leave comments and provide your better solutions. Critics are welcome.

References

Blog: Web to native code communication on iOS using WKScriptMessageHandler
Blog: Using WebKit to call WKWebView JavaScript from Swift and Swift from JavaScript
SO: My comments on this SO question
You may love my creative iOS app. Record your life notes just by tapping your mobile device. Keep your memory fresh when you review those taps with the time, location, and notes you add: TapMyNotes app
My work tool is Xcode ver 13.4 and Swift ver 5.

Tuesday, August 02, 2022

HTML Head Settings

Recently, I have been busy working on my iOS updates. One feature I want to add is to provide some information views in the app.

There are many ways to present information on display in an app. I could use a rich-text component or a text view with attributed strings. However, compared to HTML, I prefer to use a web viewer to display HTML content. The most recent update and recommended strategy by Apple is WKWebView. This component fully supports HTML5 features with extensive Apple support for iOS devices, such as dynamic text size, zooming and pinch support, accessibility support, and more.

ViewController With WKWebView

With the HTML strategy, I could use HTML to format my information content with css styles, images, and js scripts. The way it works is just like a web server/client fully functional environment. My project acts like a web server. I place all my HTML files, images, css files, and js files into groups. Add a view controller class with WKWebView as the main container.

class MyHTML1ViewController: UIViewController {
private var webView: WKWebView!
var htmlFile: String = "" // default value, can be changed
override func viewDidLoad() {
super.viewDidLoad()
let url = Bundle.main.url(
forResource: htmlFile,
withExtension: "html")
let request = URLRequest(url: url)
webViewBase.load(request)
}
...
}

Then an html file can be loaded into the view, and the content is displayed in a way similar to a web browser.

Localization

In my project, Xcode provides support for localization. All HTML files, image files, and css files can be localised based on language support in my project. Currently, I have 3 languages to support, plus a base. A total of 4 sets of files are automatically created for me in my project. Taking an HTML file as an example, 4 HTML files are created for each language, and they are placed into a subfolder named by its language identifier. The same is true for images and css files.

Here is a snapshot of my project for groups of HTML-supported files. I group them into js, css, images, and html group names.

As you can see, each localizable item has a list of supported languages. With this visual layout, I can easily pick a language file and do my translation work.

The file structure is very different from the visual view of the project. Actually, all files are in the same root folder of projects. It is really hard to find them if I want to open Finder to find a file. That's why I named all HTML-supported files with a prefix of html_.

Further investigation, I found that within my app main bundle, all HTML supported localizable files within the project are placed in subfolders by the name of language identifiers. In other words, in my app bundle, all localised files are placed in a subfolder named as the language identifier. For example, for English, "en.lproj" subfolder contains all localised files, including my HTML-supported files. One level up from language subfolders is the root path, where all none-localized files sit. For example, js files are at the root level.

As I present all this in the above pictures, I will try to explain my understanding of how web server/client works within my app project. This picture of file layout is the web server's path structure. When an html file is loaded into WKWebViewer, all related images and css files are in the same path as the html file. Up one level is the place where js files are located.

With this understanding, I can edit my html files to refer to other source files and components easily. WKWebView is something like a browser to present HTML content and let users review and interact with it. As a client, the viewer has knowledge about where to get those sources and components from my project. I call it a server.

Keep in mind, I integrated WKWebView views into my project is based on HTML support and functionality. However, my app, built by my project, does not provide any end points for external web clients to access. My app is a native iOS app running on an iOS device.

Duplication of Settings in the head Section

I have several HMTL files to be presented by a number of view controllers with WKWebView, currently about, information and setttings. There will be expanded to more, let's say n HTML contents. Four language sets are supported in my project, and might be increased to more, m languages supported. You can imagine that n x m HTML files are in my project.

One thing I realise is that within an HTML file, in the document.head section, there are many settings. For example, common and specific css source files, common and specific js libray files, and meta configuration for various settings such as view point. Some of them are the same or repeated in all HTML files.

I realised there would be a maintenance issue. If any of these common parts are changed, as I will find some interesting feature support, I have to edit all those HTML files to do just copy and paste work. Is there any better way to do the maintenance job? Actually, I had encountered some issues where I forgot to update some languages, and those language displays did not work in the way I expected.

Seeking Help from SO

StackOverflow is a community of IT programmers' participation network. There are many talented people there to support others with all kinds of questions. After struggling to find a solution, I posted my question there. I was hoping to get advice from talented people.

Before I posted my Q, I tried various ways, including using Swift within my project. There is one way to open an HMTL url from my project. Then I could do parameter replacement of the content of the HTML file as a string. However, I remembered that I tried this method before. I just could not change any files within my application bundle!

The short story is that I tried to use a plist file within my project to save some setting changes. No errors are thrown out when some new changes are saved to the plist file. However, when the settings were read out later, they were back to their original values. I had been struggling for days to find out why, and finally I found that the plist file in the project bondle cannot be changed!

I resolved the issue by copying the plist file to the application sandbox supported folder. The plist file can be edited and saved there. After that, I come to my explanation: it may be a security reason that files within the app bundle cannot be changed.

I could copy the HTML file to outside of the bondle path and make changes there. What about other HTML sources and library files? It just defeats the language support naturally provided by the iOS framework if I have to find out or identify which language is supported, and then copy all those files from specific language subfolders out.

I knew there is another way to load an HTML string directly into WKWebView. The string can be changed with a parameter replacement. This would display HTML content. However, the same issue comes back to me again. How about linking other sources and library files if I load the view with a string? No path information from the string

Since I am using HTML technology, naturally I should find a way in HTML or js to inject common head settings into my loading HTML file.

Partial Working Solution

Within about a day of my post, I got two answers. One is using js to inject common settings from a js function. I tried it immediately. It did not work at first.

When I went back to my Q, my Q was marked as [losed] by a senior member of SO. The reason is that my working environment was not explained clearly. More explanation is required.

With [losed] status, no more answers are allowed. This actually turns many people away. The only way I could ask for help and get attention was to update my Q and add comments. As you can see, I have done several updates, and the Q is quite lengthy. Anyway, I think I have done enough to clarify my Q on SO.

If you read my Q, you will see a solution in it. Based on the only post's answer with codes, I made some changes, and took the meta setting for charset out of my common settings. It works now in my project, just as I expected, to inject the common settings into the head section.

Even though my solution is working, I still have questions about it, and I would like to see if there is any other better solution or advice on this issue.

Since SO is a member participation and support community, I need to get some people's help to turn off the [close] status. What is required is to have 2 more requests at the link of reopen, at the end of my Q.

References

OS quetion: Anyway to include file in HTML for meta settings?
As a prof that my iOS is a native app, see my app blog.

Thursday, May 12, 2022

Update Block of Codes with VIM

Recently I have been working on my iOS app project. One thing I need to do is to update several blocks of codes in a code file. The update is to add directives #if...#endif to the matched block of codes. Those blocks of codes have very similar pattern:

private func configureSearchControllerDelegates(_ sc: UISearchController)
{
    log.logMessage() {
        return "configureSearchControllerDelegates"
    }
  ....
}

The first thing is to find the matched block of codes. Use the following command:

\(\s*log.logMessage()\s*{\_.\{-}}\)

Here is the explaination

\( and \) is for grouping. Starting from spaces \s and then log.logMessage(), followed by many spaces till the char of {. After that many lines of any chars till the char of }. \_. is for multiple lines, and {-} for none-greedy match(matches 0 or more of the preceding atom, as few as possible).

In VIM, the matched codes are marked as red.

With above verification, it is time to add my desired directive codes around the matched block of codes. Here is the replacement command.

:%s/(\s*log.logMessage()\s*{\_.\{-}}\)/#if D_1\r\1\r#endif/

Here is the explaination

Replacing the matched codes: insert #if D_1 as the first line, then the matched codes as group by\1. Finally add the last line of #endif after the matched codes. \r is a line break.

Here is the replacement command in VIM:

and wallah is the result:

References

Previous blog: VIM Tip: Not Containing Pattern (3)

Friday, March 18, 2022

Removing Duplicated Lines by VIM

Recently I have interest in GPS location coordinates. In my TapToCount-3W iOS app, there is a feature to record location information for each tap.

I have been puzzled by a scenarior for long time. For example, if I make several taps at same location, the GPS locations spead within a range, several tens of meters to meters apart, 30 meters or 8 meters as examples.

Further invetigation, I found that the decimal points of GPS coordinates are related to location accuracy. The more decical points are in coordindates, the more accuracy.

VIM is a powerful tool. The following is a real case of my invetigation and analysis of GPS coordindates by using VIM.

Export GPS Information

First, I have to get GPS location coordates from my app. I use the Export feature to share the result of cvs file to my mac.

Using Numbers to open the csv file. The tap information includes my sleep times between Dec 2018 to Mar 2022, 7484 lines of taps I made. From GPS coordinates, I see the decimal points up to 14 digits.

For example, here is a coordinate of latitue, longitue, and altitue value:

53.55404449631790,	-113.2990255394140,	692.3739891052250

Find Duplicate GPS Information

7484 lines are quite a lot of information. I need to find out if there is any duplicated information.

Use the following command to find duplicate coordinate information:

/\(T-\d\)\(.*\)\n\(.*\2\n)\+

Match pattern explaination: first group beginning with "T-" and a digit, then any charts (coordinates) as second group, new line, next or more lines of any charts followed by the matched second group (coordinates).

The result is as followings:

Remove Duplicate Coordinate Lines

With about search result, I can then proceed removing duplicate coordinate lines.

Use the following command to remove duplicate coordinate information:

:%s/\(T-\d\)\(.*\)\(\n.*\2\)\+/\1\2/

Replacement command explaination: replace the matched pattern (duplicate GPS coordinate lines with group 1 and group 2 defined in the matched pattern.

Analysis Results

With VIM search and replacement as a convenience and powerful tool, I can do my research and analysis on GPS coordinates collected in my TapToCount-3W app.

Using Numbers, I can get coordinate values with different decimal digits, and find out what duplicate coordinates.

7,485 Taps with GPS coordindates

Decimal
Places

Degrees

Duplicates

Unique

5246

2239

0.1

5245

2240

0.01

5245

2240

0.001

5222

2263

0.000 1

4711

2774

0.000 01

4638

2847

0.000 000 000
000 00

577

6908

Based on above analysis, I think that the best decimal points should 5, 4, or 3 places, with accuracy corespoinding to +/-0.555m, +/-5.55m, or +/-55.5m. This will reduce duplicate coordinates up to 68% to 70%.

By using VIM, I did further analysis. I export a group of taps from Jan 1, 2022 to now (Mar 19, 2022), which I know for certain that they(454 taps) were tapped at the same location. The following are 2 results: one with altitute into consideration and another with no altitute.

454 Taps with GPS coordindates and altitude

Decimal
Places

Degrees

Duplicates

Unique

444

0.1

444

0.01

444

0.001

442

0.000 1

255

199

0.000 01

434

0.000 000 000
000 00

444

454 Taps with GPS coordindates and NO altitude

Decimal
Places

Degrees

Duplicates

Unique

453

0.1

453

0.01

453

0.001

452

0.000 1

444

0.000 01

421

0.000 000 000
000 00

446

With above research results, they helps me better to understand GPS coordindate information, and to take better and effective strategies for updating my app freatures and interfaces for my app users.

References

wifiGPS.com: Accuracy versus decimal places
StackExchange - GIS: Measuring accuracy of latitude and longitude?
StackOverflow: Removing duplicate rows in vi?
StackExchange - Vi and VIM: Delete all consecutive duplicates
TapToCount-3W web page
App Store: TapToCount-3W

Saturday, December 10, 2022

References

Saturday, September 03, 2022

Multiple Selection in Export View

Problem for visible cells

Found a Soltion!

References

Friday, August 19, 2022

Set the Correct Core Data Store Options

Add a New Version of the Database

Add Your Customized Updates

References

Friday, August 12, 2022

Working Environment

A Case Study

WKScriptMessageHandler as a Gateway

Build My Gateway Class

Set it up on the Swift Side

HTML and JS Configuration

References

Tuesday, August 02, 2022

ViewController With WKWebView

Localization

Duplication of Settings in the head Section

Seeking Help from SO

Partial Working Solution

References

Thursday, May 12, 2022

References

Friday, March 18, 2022

Export GPS Information

Find Duplicate GPS Information

Remove Duplicate Coordinate Lines

Analysis Results

References

Blog Archive

Categories by Labels

Subscribe To

About Me

`WKScriptMessageHandler` as a Gateway