Forem: Shivam Maggu

Working with UserDefaults in iOS

Shivam Maggu — Fri, 22 Dec 2023 12:20:21 +0000

UserDefaults provides a database to store data and it is available as long as the app is installed.

Features
Usage
- Utilising the default shared instance of UserDefaults.
- Creating a UserDefaults that can be shared with multiple apps and extensions.
- Storing custom objects in UserDefaults.
- Using UserDefaults as a Property Wrapper

Features

The UserDefaults class provides access to the user's defaults database.
It stores data persistently across the app launches as long as the app is installed.
Access to the data is private to the app unless shared through App Groups.
Access to this database is thread-safe.
It is a key-value store that works through a property list (plist) file.
Supported data types include String, Bool, Date, Array, Dictionary, Data and Numbers.
Custom objects can be stored by encoding them as data.
We can use this to store non-sensitive data such as user preferences.

Usage

Utilising the default shared instance of UserDefaults.

import Foundation
// Set a key value in UserDefaults
UserDefaults.standard.set("Shivam", forKey: "firstname")
// Get a key value from User
DefaultsUserDefaults.standard.value(forKey: "firstname")
// Empty User
DefaultsUserDefaults.standard.removeObject(forKey: "firstname")

Creating a UserDefaults that can be shared with multiple apps and extensions.

import Foundation
// User Defaults with Suite.
// Useful for sharing data with other apps
// or extensions with app groups.
let defaults = UserDefaults(suiteName: "group.com.organisation.appname")!
// Set a key value in User Defaults
defaults.set("Shivam", forKey: "firstname")
// Get a key value from User Defaults
defaults.value(forKey: "firstname")
// Empty User Defaults
defaults.removeObject(forKey: "firstname")

Storing custom objects in UserDefaults.

import Foundation

// Custom model to be stored in UserDefaults
struct Student: Codable {
    let firstname: String
    let lastname: String
    let grade: Int
    let subjects: Array<String>
    let teachers: [String: String]
    let profileImage: Data
    let dateModified: Date
}

// Student Object
let student = Student(firstname: "John",
                      lastname: "Doe",
                      grade: 2,
                      subjects: ["Hindi", "English", "Maths"],
                      teachers: ["Hindi": "Teacher A", "English": "Teacher b", "Maths": "Teacher X"],
                      profileImage: Data(),
                      dateModified: Date())

// Encode custom object to data and store it in UserDefaults
let encoder = JSONEncoder()
do {
    let data = try encoder.encode(student)
    UserDefaults.standard.setValue(data, forKey: "StudentData")
} catch {
    throw error
}

// Retrieve data from UserDefaults and decode it to custom object
let decoder = JSONDecoder()
if let data = UserDefaults.standard.value(forKey: "StudentData") as? Data {
    do {
        let object = try decoder.decode(Student.self, from: data)
        print(object)
    } catch {
        throw error
    }
} else {
    print("No data in Defaults.")
}

Using UserDefaults as a Property Wrapper

Check out this gist to use UserDefaults with Property Wrapper. This is a more generalized way to use in Projects.

Offline Persistent Storage in iOS Applications

Shivam Maggu — Thu, 21 Dec 2023 18:35:18 +0000

In this article, we will discuss the various kinds of persistent storage options provided by Apple for iOS applications.

What is offline storage?
Why do we need it?
When should we use it?
How should we use it?

What is offline storage?

It is a kind of storage not on a network but on a physical device. In regards to an iOS application, it means that the data generated or displayed by an app is not stored on or retrieved from a network. Instead, it resides locally in the user's device.

Why do we need it?

It makes the app more accessible to the users. They are not dependent on the internet to use the app's functionality.

When should we use it?

Let's take examples of some popular apps that do not hinder user functionality when offline.

Chat apps such as Telegram and WhatsApp can store your messages when offline and deliver them when the connection is restored.
Automation apps like Automate store users flow offline.
Offline dictionaries store the words and their definitions on the device.
E-book reading apps store the books offline so users can read anytime and anywhere.
Mail apps like Gmail and Outlook queue your recently sent emails in Outbox and send them once online.
Contacts and SMS apps store phone numbers and text messages.
OTT apps provide download features to store your favourite TV Shows and Movies locally and watch offline.
Todo lists, reminders, calendars, sketching and fitness tracker apps store data offline.
YouTube and Spotify can download our favourite songs to local storage.

We should use offline persistent storage when an app calls for such use cases. We can also use offline storage to cache data models fetched from the REST APIs.

How should we use it?

If your app architecture calls for offline storage there are various ways to achieve this in iOS. Mentioned below are some examples provided directly by Apple.

UserDefaults
KeyChain
Property List
FileManager
URLCache
Core Data

I'll be adding a separate article discussing the features, implementation and use case for each storage technique.

Understanding SwiftUI - Why are Views in SwiftUI Struct and not Class?

Shivam Maggu — Sun, 26 Feb 2023 00:52:46 +0000

In this 2nd article on Understanding SwiftUI, let's discuss how views work in SwiftUI.

Why SwiftUI prefers Struct over Class?
SwiftUI Views versus UIKit Views

Why SwiftUI prefers Struct over Class?

SwiftUI Views are structs instead of classes. This avoids having multiple inherited properties, keeps them lightweight and improves performance.
SwiftUI Views are passed by value. This avoids retain cycles and reference counting, leading to fewer memory leaks.
SwiftUI is based on the core principle of maintaining a Single Source of Truth.
- View rendering depends on properties like the @State, @ObservableObject and so on. These are known as a Source of truth.
- When the value of these properties changes, the SwiftUI framework asks the view body to render the UI with the updated values.
- With UIKit, developers manage not only the state of the data but also the view changes based on that data. Whenever a view reads a piece of data, it creates a dependency between them. On data change, views should be updated to reflect the new value. When it fails to do so, then it becomes a bug. There can be multiple states in our app and multiple functions reacting to those state changes. If we do not maintain a source of truth for the current app state, UI bugs tend to creep in due to human error.
- SwiftUI tends to overcome this issue by making body the only entry point. Despite the numerous states an app might find itself in, there is only one possible way to update the UI which is by rendering the view body. Views react to state changes by informing the framework. The framework then recomputes the derived values and generates the body with updated derived values.

SwiftUI Views versus UIKit Views

Serial No.	SwiftUI Views	UIKit Views
1.	Views alone are the fundamental building blocks.	Views and Controllers work together to form the building blocks.
2.	Views are data-driven.	Views and Controllers are event-driven.
3.	Views are a struct that conforms to the `View` protocol.	Views are a class that conforms to the `UIView` class.
4.	Views are passed by value.	Views are passed by reference.
5.	Views stacked one on top of another are allocated on a stack.	Views are allocated their own designated space in memory.
6.	Views do not inherit any stored properties.	Views inherit stored properties from the parent class.
7.	SwiftUI makes use of multiple single-purpose views.	UIKit views are multipurpose and can be moulded as per our requirements.
8.	Views have only one entry point, the `body`. View maintains a state (source of truth), computes derived values based on the state and updates the body.	Views can have multiple entry points for updating their UI. If the happy path of the flow and possible edge cases (unhappy path) are not accounted for, it can lead to UI bugs.
9.	Views are independent and isolated until they are bonded to other views by a single source of truth.	View properties can be altered from anywhere within the code, making it difficult to maintain the state and leaving the code prone to UI bugs.
10.	Views are lightweight as they only store properties that are declared in them. No additional allocation or reference counting is required.	Views can become complex as they store not only the properties that we declare but also the properties of their parent. So, there is an additional allocation that we might not require. Reference counting is required as properties might hold a reference to other classes.

Understanding SwiftUI - What is SwiftUI? 🧐

Shivam Maggu — Mon, 20 Feb 2023 21:27:21 +0000

In this concise and no-nonsense article, let's postulate what SwiftUI is and why it is all the hype within the iOS developer community.

Requirements
The basics
Pros
Cons

Requirements

The minimum deployment target version is iOS 13 and above.
SwiftUI development is supported by Xcode version 11 and above.

The basics

SwiftUI is a UI Design Framework just like its predecessor, the UIKit.
It uses the Declarative programming approach as opposed to Imperative programming.
In simple words, we inform the framework of what should be done based on a state change and it handles the rest.
Whereas in the Imperative approach, we keep track of the state and instruct the framework on how to change the UI.
SwiftUI uses struct to create views instead of class.

Pros

SwiftUI helps developers write simple, clean and less code.
It manages the state better than the Imperative approach of UIKit.
Supports cross-platform development for iOS/iPadOS, macOS, tvOS and watchOS.
It uses Live Previews instead of building the project to view UI changes.
There are no auto layout issues as it always generates satisfiable layouts.
People working in teams no longer have to suffer merge conflicts in storyboards. 😜
It can be used alongside UIKit using UIHostingController.
It supports reactive programming using ObjectBinding, BindableObject and the Combine Framework.

Cons

Users with iOS version 12 and below will not be able to use apps developed with SwiftUI.
Team development might take more time as others might not be familiar with SwiftUI.

Processing payments using Stripe SDK iOS

Shivam Maggu — Wed, 08 Feb 2023 22:10:33 +0000

This guide explains how to install and set up Stripe SDK on your iOS application.

Aim
Minimum iOS Deployment Version
Stripe Frameworks
Requirements
Proof of Concept
Setup
- Adding the Stripe dependency
- Getting started with Stripe Developers Dashboard
- Setup Stripe in your iOS App
- Address collection
- Enable card scanning
- Process payments using Apple Pay
- Return to the app automatically after external authentication
- Clear cookies on logout
FAQ
Resources

Aim

Open the inbuilt Address and Payment Sheet of Stripe and start accepting payments from your customer.

Minimum iOS Deployment Version

12.0

Stripe Frameworks

Stripe (22.8.4)
StripeApplePay (22.8.4)
StripeCore (22.8.4)
StripeUICore (22.8.4)

Requirements

MacBook / MacOS
CocoaPods installed on your system
Xcode
Terminal

Proof of Concept

iOS project and test backend for processing payments with Stripe SDK.

shivammaggu / payments-using-stripe

Start accepting payments from your customers through your iOS app using Stripe SDK

payments-using-stripe

Checkout this article for recreating or setting up this demo project

Hashnode

Simulator Screen Recording of the Project

Simulator.Screen.Recording.-.iPhone.14.Pro.-.2023-02-03.at.07.40.52.mp4

View on GitHub

Setup

Adding the Stripe dependency

Open Terminal in the project directory and do pod init.
Open the newly created Podfile and set the iOS version to 12.0.


 # Uncomment the next line to define a global platform for your project
 platform :ios, '12.0'

Add the Stripe dependency to the Podfile.


 target 'payments with stripe' do
   # Comment the next line if you don't want to use dynamic frameworks
   use_frameworks!

   # Pods for payments with stripe

   pod 'Stripe'

 end

Save the Podfile and do a pod install on the Terminal. The following dependencies showed be installed.


pod install

Analyzing dependencies
Downloading dependencies
Installing Stripe (22.8.4)
Installing StripeApplePay (22.8.4)
Installing StripeCore (22.8.4)
Installing StripeUICore (22.8.4)
Generating Pods project
Integrating client project

Close the payments with stripe.xcodeproj and open payments with stripe.xcworkspace.
Select a simulator and run the project. The project should run successfully with a blank screen.

Getting started with Stripe Developers Dashboard

This process should be done once. All the teams will use the same Dashboard. (Backend, iOS, Android etc.)

Go to stripe.com and click on start now.
Follow the steps as directed by the website to complete the registration process.
Complete the email verification and set up your business details for which payments will be accepted by Stripe.
On the Stripe Dashboard, you should be able to see your Publishable key and Secret key for both test mode and live mode.
1. The publishable key is used on the client side such as in iOS, android or web apps.
2. The secret key is used on the server side. (Secret key should not be stored on client-facing apps.)

Setup Stripe in your iOS App

Open AppDelegate.swift and add the Publishable key inside the didFinishLaunchingWithOptions method. The publishable key can be retrieved from the Stripe Developers Dashboard.


  StripeAPI.defaultPublishableKey = "Insert your key here"

Use the test mode keys during the testing and development phase, and the live mode keys when publishing the app.

We need to hit a POST API to create the payment intent and in return receive the following data. This data is used to initialize the customer, Stripe SDK and the PaymentSheet.
- customerId
- ephemeralKey
- paymentIntent
- publishableKey

Refer to CourseCheckoutViewModel in the Proof of Concept example on GitHub.

// Creates a payment intent for the customer and fetches the important keys and id's for processing a payment

func fetchPaymentIntent(completion: @escaping ((Bool, String?) -> Void)) {

    // This could be the details for the item that the customer wants to buy

    let cartContent: [String: Any] = ["items": [["id": UUID().uuidString]]]

    self.apiClient.createPaymentIntent(cartContent: cartContent) { [weak self] (data, error) in

        guard let self = self else { return }

        guard error == nil else {
            print(error.debugDescription)
            completion(false, error.debugDescription)
            return
        }

        guard
            let customerId = data?.customerId as? String,
            let customerEphemeralKeySecret = data?.ephemeralKey as? String,
            let paymentIntentClientSecret = data?.paymentIntent as? String,
            let publishableKey = data?.publishableKey as? String
        else {
            let error = "Error fetching required data"
            print(error)
            completion(false, error)
            return
        }

        print("Created Payment Intent")

        self.setPublishableKey(publishableKey: publishableKey)
        self.paymentIntentClientSecret = paymentIntentClientSecret
        self.customer = .init(id: customerId,
                              ephemeralKeySecret: customerEphemeralKeySecret)
        completion(true, nil)
    }
}

Setup the PaymentSheet in your View Controller. Refer to CourseCheckoutViewController in the Proof of Concept example on GitHub.


// Create and configure the payment sheet

private func createPaymentSheet() {
    var configuration = PaymentSheet.Configuration()

    // Autofills the shipping details with the one we collected from user through AddressViewController

    configuration.shippingDetails = { [weak self] in
        return self?.address
    }

    // Configure button for Apple Pay in PaymentSheet

    configuration.applePay = .init(merchantId: "com.example.appname",
                                    merchantCountryCode: "US")

    // Provides checkbox for saving card details

    configuration.savePaymentMethodOptInBehavior = .requiresOptIn

    // Sets the return url. Used when user needs to go outside the app for authentication

    configuration.returnURL = "payments-with-stripe://stripe-redirect"

    // Configures the color of the pay button

    configuration.primaryButtonColor = .blue

    // Shows the name of the company collecting the payment

    configuration.merchantDisplayName = "Dummy Corp Inc"

    // Allows payments which requires some time to confirm

    configuration.allowsDelayedPaymentMethods = true

    // Adds default billing details for user to the payment object

    configuration.defaultBillingDetails.email = "dummy@corp.com"
    configuration.defaultBillingDetails.name = self.address?.name
    configuration.defaultBillingDetails.phone = self.address?.phone
    configuration.defaultBillingDetails.address.country = self.address?.address.country
    configuration.defaultBillingDetails.address.city = self.address?.address.city
    configuration.defaultBillingDetails.address.line1 = self.address?.address.line1
    configuration.defaultBillingDetails.address.line2 = self.address?.address.line2
    configuration.defaultBillingDetails.address.state = self.address?.address.state
    configuration.defaultBillingDetails.address.postalCode = self.address?.address.postalCode

    // Sets customer object to payment object

    if let customer = self.viewModel.getCustomer() {
        configuration.customer = customer
    }

    // Initiaises the PaymentSheet with the above config and client secret received from payment intent API

    if let paymentIntentClientSecret = self.viewModel.getPaymentIntentClientSecret() {
        self.paymentSheet = PaymentSheet(paymentIntentClientSecret: paymentIntentClientSecret,
                                        configuration: configuration)
    }
}

Handle the conditions after the payment. The following three scenarios can happen during/after the payment.


// Present user with the payment sheet and handles the various payment scenarios

private func presentPaymentSheet() {
    guard let paymentSheet = paymentSheet else { return }

    DispatchQueue.main.async {
        paymentSheet.present(from: self) { [weak self] (paymentResult) in

            guard let self = self else { return }

            switch paymentResult {
            case .completed:
                self.displayAlert(title: "Payment complete!")
            case .canceled:
                self.displayAlert(title: "Payment canceled!")
            case .failed(let error):
                self.displayAlert(title: "Payment failed", message: error.localizedDescription)
            }
        }
    }
}

On tap of the pay now button, present the payment sheet, add the payment details and click on pay.
Either the payment will be completed or it will fail if there are issues with the payment method. We can debug the failure reasons in the following link.
Payment can also result in cancellation if the user dismisses the PaymentSheet.

Address collection

We can set up the AddressViewController to display a form for collecting names, addresses, cities, countries, postal codes and phone numbers.


 // Setup and display the address sheet

 private func presentAddressCollectionController(_ controller: CourseCheckoutViewController) {
     let addressConfiguration = AddressViewController.Configuration(additionalFields: .init(name: .required,
                                                                                            phone: .required),
                                                                     allowedCountries: [],
                                                                     title: "Billing Address")
     let addressViewController = AddressViewController(configuration: addressConfiguration,
                                                       delegate: controller)

     let navigationController = UINavigationController(rootViewController: addressViewController)
     self.rootViewController.present(navigationController, animated: true)
 }

Set up the delegate method to get the address details filled in by the customer.


 extension CourseCheckoutViewController: AddressViewControllerDelegate {

     func addressViewControllerDidFinish(_ addressViewController: Stripe.AddressViewController, with address: Stripe.AddressViewController.AddressDetails?) {
         addressViewController.dismiss(animated: true) {
             debugPrint(address as Any)

             self.address = address
         }
     }
 }

The address details collected from the user should be passed to PaymentSheet Configuration. This will auto-fill the details in the PaymentSheet and also send the customer details to Stripe Dashboard.
Collecting these details is essential if the Stripe account is registered in India but the users are paying in international currency. More on this here.


 var configuration = PaymentSheet.Configuration()

 configuration.shippingDetails = { [weak self] in
     return self?.address
 }

Enable card scanning

To enable the option for scanning debit/credit cards, add the following key to the info.plist file.


  <key>NSCameraUsageDescription</key>
  <string>Allow the app to scan cards.</string>

This feature is available on iOS 13.0 and above.

Process payments using Apple Pay

Steps for integrating Apple Pay are well documented in the links below.

Please check out this tutorial for adding Apple Pay as a payment option to your app.

Add an Apple pay button on your PaymentSheet by editing the configuration as follows.


var configuration = PaymentSheet.Configuration()
configuration.applePay = .init(merchantId: "merchant.com.your_app_name",
                               merchantCountryCode: "US")

Return to the app automatically after external authentication

A customer may go out of your app for authentication purposes, for example, in Safari or their banking app to complete payment.

To allow them to automatically return to your app after authenticating, configure a custom URL scheme or universal link and set up your app delegate/scene delegate

(If using scene delegate for iOS 13 and above) to forward the URL to the SDK.

AppDelegate.swift


  // This method handles opening custom URL schemes
  // (for example, "your-app://stripe-redirect")

  func application(_ app: UIApplication,
                    open url: URL, 
                    options: [UIApplication.OpenURLOptionsKey : Any] = [:]
  ) -> Bool {

      let stripeHandled = StripeAPI.handleURLCallback(with: url)

      if !stripeHandled {

          /*
            This was not a stripe url, do whatever url handling your app
            normally does, if any.
            */
      }

      return true
  }

  // This method handles opening universal link URLs
  // (for example, "https://example.com/stripe_ios_callback")

  func application(_ application: UIApplication,
                    continue userActivity: NSUserActivity,
                    restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void
  ) -> Bool  {

      if userActivity.activityType == NSUserActivityTypeBrowsingWeb {

          if let url = userActivity.webpageURL {

              let stripeHandled = StripeAPI.handleURLCallback(with: url)

              guard !stripeHandled else { return true }

              /*
                This was not a stripe url, do whatever url handling your app
                normally does, if any.
                */
          }
      }

      return false
  }

SceneDelegate.swift


  func scene(_ scene: UIScene,
              openURLContexts URLContexts: Set<UIOpenURLContext>) {

      if let urlContext = URLContexts.first {

          let url = urlContext.url
          let stripeHandled = StripeAPI.handleURLCallback(with: url)

          if !stripeHandled {
              // This was not a stripe url, do whatever url handling your app
              // normally does, if any.
          }
      }
  }

Also, a returnURL should be configured in the PaymentSheet.Configuration object to the URL for your app.


var configuration = PaymentSheet.Configuration()
configuration.returnURL = "payments-with-stripe://stripe-redirect"

Clear cookies on logout

PaymentSheet related cookies and other authentication data should be cleared when a user logs out of the app. Add the following code to your logout function.


import Stripe

// Resets all payment and user related cache
// Should be called when user logs out of the app

func logout() {

    /*
      Perform all other logout related steps here
      */

    PaymentSheet.resetCustomer()
}

FAQ

Stripe SDK can be installed using CocoaPods, Carthage, and Swift Package Manager.
The latest version v23.3.2 or above of Stripe iOS SDK requires Xcode 13.2.1 or later and is compatible with apps targeting iOS 13 or above.
For iOS 12 support use v22.8.4.
For iOS 11 support use v21.13.0.
For iOS 10 support use v19.4.0.
For iOS 9 support use v17.0.2.
Why was my card declined when trying to make a payment? Check the reason for your decline code.
Got an error message while processing your payment? Check the reason in this article.

Resources

Stripe SDK on CocoaPods
Stripe SDK on GitHub
Stripe API Reference
Stripe Documentation
Stripe iOS SDK Documentation
Installing Stripe SDK using CocoaPods
About API Keys
Test mode and Live mode
Accepting Payments with Stripe
Collecting User's Address
Dummy Credentials for testing payments
Accept payment from regions outside of India
Adding multiple payment methods
Debug card Decline Codes
Understanding payment Error Codes
Collecting user phone numbers through the backend
Adding additional articles on security when processing payments using Stripe:

Forem: Shivam Maggu

Working with UserDefaults in iOS

Table of Contents

Features

Usage

Utilising the default shared instance of UserDefaults.

Creating a UserDefaults that can be shared with multiple apps and extensions.

Storing custom objects in UserDefaults.

Using UserDefaults as a Property Wrapper

Offline Persistent Storage in iOS Applications

Table of Contents

What is offline storage?

Why do we need it?

When should we use it?

How should we use it?

Understanding SwiftUI - Why are Views in SwiftUI Struct and not Class?

Table of Contents

Why SwiftUI prefers Struct over Class?

SwiftUI Views versus UIKit Views

Understanding SwiftUI - What is SwiftUI? 🧐

Table of Contents

Requirements

The basics

Pros

Cons

Processing payments using Stripe SDK iOS

Table of Contents

Aim

Minimum iOS Deployment Version

Stripe Frameworks

Requirements

Proof of Concept

shivammaggu / payments-using-stripe

Start accepting payments from your customers through your iOS app using Stripe SDK

payments-using-stripe

Checkout this article for recreating or setting up this demo project

Simulator Screen Recording of the Project

Setup

Adding the Stripe dependency

Getting started with Stripe Developers Dashboard

Setup Stripe in your iOS App

Address collection

Enable card scanning

Process payments using Apple Pay

Return to the app automatically after external authentication

Clear cookies on logout

FAQ

Resources