So if you’re an iOS developer, you should also learn to prioritize security at every stage of app development.

Swift, Apple’s modern programming language, offers a wealth of tools and frameworks that simplify development while enhancing security, but only when used correctly.

This article explores 10 common security pitfalls in Swift-based iOS apps and offers practical strategies to mitigate them.

Prerequisites

Before diving in, you’ll need:

• Working knowledge of Swift and iOS development.

• Access to Xcode.

• Basic understanding of how iOS apps communicate with servers.

• Familiarity with Terminal/command line basics.

The code examples are practical and explained step-by-step, making them accessible to junior developers while still offering value to experienced ones looking to strengthen their app's security.

What we’ll cover:

• What are the Most Prevalent Security Traps in Swift iOS Applications?
  • 1. Insecure Data Storage
  • 2. Weak Network Communication
  • 3. Improper Input Validation
  • 4. Hardcoding Secrets
  • 5. Insufficient Authentication and Authorization
  • 6. Insecure Logging and Error Handling
  • 7. Ignoring Code Obfuscation and Reverse Engineering
  • 8. Insecure Third-Party Libraries
  • 9. Insufficient Biometric and Multi-Factor Authentication
  • 10. Disregarding Periodic Security Testing

What are the Most Prevalent Security Traps in Swift iOS Applications?

Swift and iOS offer robust security features, but mistakes still happen. Following are the most common traps and how to fix them:

1. Insecure Data Storage

Among the most common mistakes developers make is having sensitive data stored insecurely. Passwords, tokens, or even individual user data can be left by accident in UserDefaults or local storage in unencrypted form.

While UserDefaults is convenient for small amounts of data, it is not secure for sensitive data as it is so easily accessible to attackers if the device is compromised.

How to Fix:

Use the Keychain Services API to securely store sensitive data. Keychain encrypts data and binds it to the device so that it can't be accessed by other unauthorized applications or users.

You can securely store credentials using libraries in Swift such as KeychainAccess or the built-in SecItemAdd and SecItemCopyMatching functions.

For example, this how you can store a user password in Keychain so as to ensure sensitive data is stored securely:

do {

try keychain.set("userPassword123", key: "userPassword")

} catch {

    print("Error saving to Keychain: \(error)")

}

Behind the scenes, here’s what happens when you call keychain.set("userPassword123", key: "userPassword") inside a KeychainManager class that uses Apple’s native Security framework for storage:

import Security

class KeychainManager {
 func set(_ value: String, key: String) throws {
     // 1. Convert string to Data
     guard let data = value.data(using: .utf8) else {
         throw NSError(domain: "KeychainManager", code: -1)
     }

     // 2. Build the query dictionary
     let query: [String: Any] = [
         // Store as password
         kSecClass as String: kSecClassGenericPassword,
         // Your app's bundle identifier
         kSecAttrService as String: "com.yourapp.keychain",
         // "userPassword"
         kSecAttrAccount as String: key,
         // "userPassword123" encrypted
         kSecValueData as String: data,
         kSecAttrAccessible as String: kSecAttrAccessibleAfterFirstUnlock
     ]
     // 3. Save to keychain (iOS encrypts it automatically)
     let status = SecItemAdd(query as CFDictionary, nil)
     // 4. Check if successful
     guard status == errSecSuccess else {
         throw NSError(domain: "KeychainManager", code: Int(status))
     }
 }
}

When this function runs, iOS converts the string value, such as "userPassword123", into encrypted binary data and stores it securely in the device’s Keychain database. The entry is saved under the provided key (for example, "userPassword"), and only your app can access it.

Behind the scenes, the Keychain leverages strong security features, including hardware-backed encryption using device-specific keys, optional biometric protection through Face ID or Touch ID, and app-level isolation to ensure that no other app can read or modify your stored credentials.

2. Weak Network Communication

Transmitting sensitive data over the network is another area prone to vulnerabilities. Using unencrypted HTTP connections exposes your app to man-in-the-middle (MITM) attacks, allowing attackers to intercept and modify data in transit.

The Problem: When data travels between your app and server over an insecure connection, attackers on the same network (like public Wi-Fi) can:

• Read sensitive information (passwords, personal data, payment details)

• Modify requests and responses

• Impersonate your legitimate server

How to Fix:

1. Always Use HTTPS
HTTPS encrypts all data in transit, making it unreadable to attackers. iOS's App Transport Security (ATS) enforces this by blocking insecure HTTP connections by default:

// ❌ INSECURE - HTTP connection (blocked by ATS by default)
let url = URL(string: "http://api.example.com/login")

// ✅ SECURE - HTTPS connection
let url = URL(string: "https://api.example.com/login")

You’ll want to avoid adding ATS exceptions to your Info.plist unless absolutely necessary. If a third-party API only supports HTTP, contact them to upgrade or find a more secure alternative.

2. Implement Certificate Pinning (Advanced Protection)

Even with HTTPS, your app could still be vulnerable to sophisticated MITM attacks. An attacker could install a fraudulent certificate on a user's device (through malware or social engineering), for example, and intercept HTTPS traffic that appears valid. The attacker's fake certificate would be trusted by the device, allowing them to decrypt and read "secure" communications.

Certificate pinning solves this by making your app trust only your specific server's certificate, rejecting all others – even if they're otherwise valid.

How Certificate Pinning Works:

Your app stores the expected certificate (or its public key hash) and validates it during each connection:

class SecureNetworkManager: NSObject, URLSessionDelegate {

    // Store your server's certificate hash
    // Get this by running: openssl x509 -in certificate.crt -pubkey -noout | openssl pkey -pubin -outform der | openssl dgst -sha256 -binary | base64
    private let expectedPublicKeyHash = "YOUR_CERTIFICATE_HASH_HERE"

    func urlSession(
        _ session: URLSession,
        didReceive challenge: URLAuthenticationChallenge,
        completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void
    ) {
        // Step 1: Check if this is a server trust challenge (certificate validation)
        guard challenge.protectionSpace.authenticationMethod == NSURLAuthenticationMethodServerTrust,
              let serverTrust = challenge.protectionSpace.serverTrust
        else {
            // Not a certificate challenge; use default handling
            completionHandler(.performDefaultHandling, nil)
            return
        }

        // Step 2: Validate that the server's certificate matches our pinned certificate
        if isValidServerTrust(serverTrust) {
            // Certificate matches - proceed with the connection
            completionHandler(.useCredential, URLCredential(trust: serverTrust))
        } else {
            // Certificate doesn't match - reject the connection to prevent MITM attack
            completionHandler(.cancelAuthenticationChallenge, nil)
        }
    }

    // Validates the server's certificate against our pinned hash
    private func isValidServerTrust(_ serverTrust: SecTrust) -> Bool {
        // Extract the server's certificate
        guard let serverCertificate = SecTrustGetCertificateAtIndex(serverTrust, 0) else {
            return false
        }

        // Get the public key from the certificate
        let serverPublicKey = SecCertificateCopyKey(serverCertificate)
        guard let publicKey = serverPublicKey else {
            return false
        }

        // Convert the public key to data and hash it
        var error: Unmanaged<CFError>?
        guard let publicKeyData = SecKeyCopyExternalRepresentation(publicKey, &error) as Data? else {
            return false
        }

        // Hash the public key using SHA-256
        let publicKeyHash = SHA256.hash(data: publicKeyData)
        let publicKeyHashString = Data(publicKeyHash).base64EncodedString()

        // Compare with our expected hash
        return publicKeyHashString == expectedPublicKeyHash
    }
}

What this code does, step-by-step:

1. urlSession(_:didReceive:completionHandler:) – This method is called whenever your app makes an HTTPS connection. iOS asks: "Should I trust this server's certificate?"

2. Check authentication method – We verify this is a server trust challenge (certificate validation), not some other type of authentication.

3. Validate the certificate – We call isValidServerTrust(), which:

   • Extracts the server's certificate from the connection

   • Gets the public key from that certificate

   • Hashes the public key using SHA-256

   • Compares the hash to our stored, expected hash

4. Make a decision:

• If hashes match, then the server is legitimate. Proceed with .useCredential.

• If hashes don't match, we have a potential MITM attack. Cancel with .cancelAuthenticationChallenge.

So how does this prevent MITM attacks? Even if an attacker installs a fraudulent certificate on the user's device and intercepts traffic, their certificate's hash won't match your pinned hash. Your app will reject the connection, preventing the attacker from decrypting your traffic.

3. Additional Protection: Recommend a VPN on Public Wi-Fi

You can also recommend that users connect through a VPN when on public Wi-Fi for an added layer of security, and provide guidance on how to use a VPN effectively to keep their data safe.

For developers, maintaining strong app security also depends on having a well-optimized system, learning how to speed up a slow Mac can help ensure smoother builds, faster testing, and a more secure overall development workflow.

3. Improper Input Validation

Some developers neglect correct input validation, leading to a number of vulnerabilities including SQL injection, remote code execution, and data corruption.

While Swift has strong typing support, some developers don’t sanitize user input or API responses. Incorporating real-time API email validation ensures that users provide legitimate, properly formatted email addresses before they are stored or processed, reducing both security risks and data quality issues.

How to Fix:

Input validation is your first line of defense against malicious data. Here's how to protect your iOS applications:

1. Validate User Input with Patterns

Always validate user input using regular expressions or predefined patterns before processing. For example, when accepting email addresses:

func isValidEmail(_ email: String) -> Bool {
    let emailRegex = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"
    let emailPredicate = NSPredicate(format: "SELF MATCHES %@", emailRegex)
    return emailPredicate.evaluate(with: email)
}

// Only accept properly formatted data
guard isValidEmail(userEmail) else {
    // Reject invalid input
    return
}

This ensures that only properly formatted data is accepted, preventing malformed or malicious input from entering your system.

2. Sanitize API Responses

Never trust external data. Always validate and sanitize API responses before using them:

if let userAge = apiResponse["age"] as? Int,
   userAge >= 0 && userAge <= 150 {
    // Safe to use
    user.age = userAge
} else {
    // Handle invalid data appropriately
    throw ValidationError.invalidAge
}

3. Use Parameterized Queries (Most Critical)

The most dangerous mistake is building database queries through string concatenation. Consider this vulnerable code:

// ❌ NEVER DO THIS - Vulnerable to SQL Injection
let username = userInput  // Could be: "admin' OR '1'='1"
let query = "SELECT * FROM users WHERE username = '\(username)'"
database.execute(query)

If a malicious user enters admin' OR '1'='1 as their username, the query becomes:

SELECT * FROM users WHERE username = 'admin' OR '1'='1'

This would return all users in the database instead of just one, potentially exposing sensitive data. The secure solution uses parameterized queries:

// ✅ SAFE - Using parameterized queries
let query = "SELECT * FROM users WHERE username = ?"
database.execute(query, withArgumentsIn: [username])

In this approach, the ? is a placeholder that the database treats as a parameter, not as part of the SQL command. The username value is passed separately in the withArgumentsIn array.

This means that even if a user tries to inject SQL code like admin' OR '1'='1, the database will treat the entire string as a literal username to search for – not as executable SQL code. The database engine automatically escapes any special characters, completely eliminating the risk of SQL injection.

By separating the query structure from the data, parameterized queries ensure that user input can never alter the intended logic of your SQL statements.

4. Hardcoding Secrets

API keys, credentials, or private tokens hard-coded in the source code is another serious security mistake. Attackers can extract such secrets from compiled binaries using reverse-engineering tools, especially for apps released to the public.

Once exposed, these credentials can be used to access your backend services, potentially leading to data breaches or unauthorized charges.

The Problem – Hardcoded Secrets:

// NEVER DO THIS
class APIClient {
    private let apiKey = "1234567890abcdef"
    private let secretToken = "sk_live_51H..."

    func makeRequest() {
        // These secrets are embedded in your binary
        let headers = ["Authorization": "Bearer \(apiKey)"]
    }
}

How to Fix:

Never store sensitive credentials directly in your code. Here are secure alternatives:

Solution 1: Fetch Secrets from Backend at Runtime

The most secure approach is to never store secrets on the client at all. Instead, authenticate users and let your backend make authorized API calls:

class APIClient {
    private var sessionToken: String?

    // User logs in and receives a temporary session token
    func authenticateUser(email: String, password: String) async throws {
        let response = try await backend.login(email: email, password: password)
        // Store only a temporary, user-specific session token
        self.sessionToken = response.sessionToken
    }

    // Backend handles the actual API calls with the real API key
    func fetchUserData() async throws -> UserData {
        guard let token = sessionToken else {
            throw AuthError.notAuthenticated
        }

        // Your backend receives this request, validates the session token,
        // then uses its own API keys to fetch data from third-party services
        return try await backend.getUserData(sessionToken: token)
    }
}

How this works:

Your app never knows the actual API keys. When a user needs data, your app sends a request to your own backend server with a session token. Your backend validates the token, then uses its own securely stored API keys to make the actual third-party API calls. This way, the real secrets never leave your server.

Solution 2: Environment Variables or Config Files (Development Only)

For development environments, use .xcconfig files that are excluded from version control:

// Secrets.xcconfig (add to .gitignore!)
API_KEY = your_dev_api_key_here
API_SECRET = your_dev_secret_here

// Access in your code through Info.plist
class Config {
    static let apiKey: String = {
        guard let key = Bundle.main.object(forInfoDictionaryKey: "API_KEY") as? String else {
            fatalError("API_KEY not found in configuration")
        }
        return key
    }()
}

Important: This approach is only suitable for non-production environments! Never ship production API keys with your app, even in config files.

5. Insufficient Authentication and Authorization

Relying on client-side authentication and authorization checks is risky. Attackers can cause the app to bypass these checks and access in an unauthorized way by brute forcing or tampering with the app/runtime.

How to Fix:

• Do authentication and authorization on the server side instead of the client-side.

• Use JWT (JSON Web Tokens) or OAuth 2.0 for authenticated user login.

• Token expiration and refresh logic needs to be implemented in order to minimize the likelihood of token theft.

Example: Securely sending JWT:

let request = URLRequest(url: apiURL)

request.setValue("Bearer \(jwtToken)", forHTTPHeaderField: "Authorization")

6. Insecure Logging and Error Handling

Extensive and insecure logging practices, as well as uncaught exceptions, can lead to the exposure of sensitive information including usernames, passwords, and API keys.

How to Fix:

• Log sensitive information carefully.

• Implement controlled error management and provide the minimum amount of information in user-presented messages.

• Implement secure logging libraries that mask or encrypt personal data.

do {
    try someRiskyOperation()
} catch {
    // Log error securely
    Logger.log("Operation failed: \(error.localizedDescription)")
}

7. Ignoring Code Obfuscation and Reverse Engineering

Swift binaries can be reverse-engineered to expose sensitive business logic, algorithms, or hidden secrets. Attackers use tools like Hopper Disassembler, class-dump, or IDA Pro to decompile your app and analyze how it works internally. This risk is often underestimated, especially for smaller apps, but any app can be a target.

This means that when you compile a Swift app, the resulting binary contains:

• Class names and method signatures

• String literals (URLs, error messages, keys)

• The structure of your code logic

• Algorithm implementations

An attacker can extract this information and use it to understand your app's authentication flow and bypass it, copy your proprietary algorithms, find hardcoded API endpoints or keys you thought were "hidden", discover premium features to unlock without paying, and so on.

Why It's Bad – Real Example:

Let's imagine you have a premium feature check in your app:

class FeatureManager {
    func isPremiumUser() -> Bool {
        // Check if user has premium access
        let hasSubscription = UserDefaults.standard.bool(forKey: "premium_unlocked")
        return hasSubscription
    }

    func unlockPremiumFeature() {
        guard isPremiumUser() else {
            showPaywall()
            return
        }
        // Show premium content
        showPremiumContent()
    }
}

An attacker could reverse-engineer your app and discover that the method isPremiumUser() controls access, and that it simply checks a UserDefaults key called premium_unlocked. They would then know that they could use runtime manipulation tools to set this value to true, bypassing your paywall entirely.

How to Fix:

1. Use Swift Compiler Optimizations

Enable optimization flags that strip debugging symbols and make the binary harder to read:

// In your build settings:
// - Set "Optimization Level" to "-O" (or -Osize) for release builds
// - Enable "Strip Debug Symbols During Copy" = YES
// - Set "Strip Style" to "All Symbols"

This removes function names and makes the compiled code less readable – though class/method names remain partially visible.

2. Use Symbol Obfuscation Tools

Tools like SwiftShield can rename your classes, methods, and properties to meaningless names:

// Before obfuscation (readable to attackers):
class FeatureManager {
    func isPremiumUser() -> Bool { ... }
}

// After obfuscation (harder to understand):
class a7f3b2 {
    func x9k2m() -> Bool { ... }
}

While this doesn't prevent reverse engineering, it makes it significantly harder for attackers to understand what the code does.

3. Move Sensitive Logic to the Server (Best Practice)

Instead of checking premium status locally, verify it server-side:

// ✅ Secure approach - Server validates everything
class FeatureManager {
    func unlockPremiumFeature() async {
        do {
            // Server checks if user truly has premium access
            let hasAccess = try await backend.verifyPremiumAccess(userId: currentUserId)

            if hasAccess {
                showPremiumContent()
            } else {
                showPaywall()
            }
        } catch {
            // Handle error
            showPaywall()
        }
    }
}

How this works:

Your backend maintains the source of truth about premium access. Even if an attacker reverse-engineers your app and tries to bypass the check, the server will reject unauthorized requests. The app becomes just a UI layer, while all critical decisions happen server-side – where attackers can't manipulate them.

The key principle is to assume your app code is public: never rely on client-side checks for security-critical operations like payments, access control, or authentication. Use obfuscation to make reverse engineering harder, but ultimately move sensitive logic to your secure backend

8. Insecure Third-Party Libraries

Third-party libraries are at risk if they are hacked or outdated. Developers might inadvertently prioritize app functionality over potential security risks from dependencies, and ETL tools can further help by streamlining the monitoring and processing of dependency-related data to identify vulnerabilities more efficiently.

On a broader scale, implementing strong data center security practices ensures that even if third-party components introduce risks, the underlying infrastructure remains resilient against attacks.

How to Fix:

• Use only high-quality, well-maintained libraries.

• Update dependencies and monitor CVEs (Common Vulnerabilities and Exposures).

• Audit library code if it handles sensitive data.

9. Insufficient Biometric and Multi-Factor Authentication

Most applications rely on passwords alone, which are vulnerable to being hacked. Enabling biometrics like Face ID or Touch ID enhances security for users.

How to Fix:

• Tie LocalAuthentication framework for biometric authentication.

• Combine biometrics with server-based authentication for multifactor authentication (MFA).

import LocalAuthentication

let context = LAContext()

var error: NSError?

if context.canEvaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, error: &error) {

    context.evaluatePolicy(.deviceOwnerAuthenticationWithBiometrics,

                        localizedReason: "Access your account") { success, authError in

        DispatchQueue.main.async {

         if success {

                // Proceed securely

         } else {

                // Handle failure (authError may contain the reason)

                print("Authentication failed: \(authError?.localizedDescription ?? "Unknown error")")

         }

     }

}

} else {

// Biometrics not available, check error for details

    print("Biometrics unavailable: \(error?.localizedDescription ?? "Unknown error")")

}

10. Disregarding Periodic Security Testing

Apps, despite following best practices during development, often contain unexplored vulnerabilities that emerge from complex interactions, third-party dependencies, or newly discovered attack vectors. Regular security testing is absolutely essential to discover these vulnerabilities before attackers exploit them.

Security testing should happen at multiple stages, using accessible tools and practices:

1. Automated security scans: Run automatically with every build to catch common issues.

2. Self-conducted code audits: Regular security-focused reviews of your own code using established guidelines.

3. Vulnerability scanning tools: Use free tools like MobSF to analyze your app for security flaws.

4. Dependency audits: Checking third-party libraries for known security vulnerabilities.

How to Fix:

1. Implement Automated Security Scans in CI/CD

Integrate security scanning tools into your continuous integration pipeline so every code change is automatically checked:

# Example: GitHub Actions workflow for automated security scanning
name: Security Scan

on: [push, pull_request]

jobs:
  security-scan:
    runs-on: macos-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Run MobSF Security Scan
        run: |
          # Mobile Security Framework - scans for common vulnerabilities
          docker run -v $(pwd):/app opensecurity/mobile-security-framework-mobsf

      - name: Dependency Vulnerability Check
        run: |
          # Check CocoaPods/SPM dependencies for known CVEs
          brew install dependency-check
          dependency-check --scan ./Podfile.lock --format JSON

      - name: Secret Detection
        run: |
          # Detect accidentally committed secrets
          brew install truffleHog
          truffleHog filesystem . --json

      - name: Fail build on critical issues
        run: |
          if grep -q "CRITICAL" security-report.json; then
            echo "Critical security issues found!"
            exit 1
          fi

Automated scans check for:

• Hardcoded API keys, tokens, or passwords

• Insecure network configurations (allowing HTTP instead of HTTPS)

• Weak cryptographic algorithms

• Known vulnerabilities in third-party libraries

• Improper SSL/TLS certificate validation

• Insecure data storage (storing sensitive data in UserDefaults)

• Excessive app permissions

Example output from an automated scan:

Security Scan Results:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
[CRITICAL] Hardcoded API Key Found
  File: APIClient.swift:15
  Issue: API key "sk_live_abc123..." detected in source code

[HIGH] Insecure HTTP Connection
  File: NetworkManager.swift:42
  Issue: App allows cleartext HTTP traffic to api.example.com
  Fix: Enforce HTTPS or add exception to Info.plist if required

[MEDIUM] Weak Encryption Algorithm
  File: DataEncryption.swift:28
  Issue: Using MD5 for hashing (cryptographically broken)
  Fix: Use SHA-256 or better

[LOW] Outdated Dependency
  Library: Alamofire 4.2.0
  Issue: Known vulnerability CVE-2021-12345
  Fix: Update to version 5.6.0 or later
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Build Failed: 2 critical issues must be fixed before deployment

2. Use MobSF (Mobile Security Framework) for Vulnerability Analysis

MobSF is a free, automated tool that analyzes your iOS app for security issues:

# Install and run MobSF locally
docker pull opensecurity/mobile-security-framework-mobsf
docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf

# Upload your .ipa file through the web interface at localhost:8000
# MobSF will analyze and provide a detailed security report

What MobSF checks:

• Binary analysis for hardcoded secrets

• Insecure data storage patterns

• Weak cryptographic implementations

• Insecure network connections

• Code quality and security best practices

• Compliance with security standards

3. Conduct Regular Code Audits Using OWASP MSTG

Use the OWASP Mobile Security Testing Guide as a checklist to audit your own code:

// Example: Following OWASP MSTG recommendations for secure storage
class SecureStorage {
    // ❌ Insecure - UserDefaults is not encrypted
    func saveTokenInsecurely(_ token: String) {
        UserDefaults.standard.set(token, forKey: "authToken")
    }

    // ✅ Secure - Using Keychain as OWASP recommends
    func saveTokenSecurely(_ token: String) throws {
        let data = token.data(using: .utf8)!
        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrAccount as String: "authToken",
            kSecValueData as String: data,
            kSecAttrAccessible as String: kSecAttrAccessibleWhenUnlockedThisDeviceOnly
        ]

        SecItemDelete(query as CFDictionary)
        let status = SecItemAdd(query as CFDictionary, nil)

        guard status == errSecSuccess else {
            throw StorageError.saveFailed
        }
    }
}

OWASP MSTG Checklist for Self-Audit:

• [ ] Are all sensitive data encrypted at rest?

• [ ] Is HTTPS enforced for all network calls?

• [ ] Are certificates properly validated?

• [ ] Is sensitive data excluded from logs?

• [ ] Are API keys and secrets not hardcoded?

• [ ] Is user input validated and sanitized?

• [ ] Are authentication tokens stored securely in Keychain?

4. Automated Dependency Scanning

Monitor your dependencies continuously for newly discovered vulnerabilities:

# For CocoaPods projects
gem install cocoapods-audit
pod audit

# For Swift Package Manager
# Use GitHub Dependabot (free for public repos) or
brew install swift-outdated
swift-outdated

And set up automated alerts with these tools:

• GitHub Dependabot: Automatically creates PRs when vulnerable dependencies are detected (free)

• Snyk: Free tier available for open-source projects

• OWASP Dependency-Check: Free command-line tool

Conclusion

Developing secure iOS apps using Swift is all about forward-thinking. You should do all you can to avoid these common errors, like insecure storage of data, poor network communication, hard-coded secrets, or poor authentication.

Using Keychain for confidential information, requiring HTTPS, input validation, and multifactor authentication are all steps that decrease risk.

Regular testing for security vulnerabilities and limiting third-party library use can also further enhance your app's security.

Security is a continuous responsibility. Swift provides tools, but the developers need to apply those tools carefully. Security being tackled right from the start protects users' information, creates trust, and protects the reputation of the application.

Hello everyone! In this article we are going to learn how to use UISearchController in iOS Apps.

What are we going to build?

We are going to build a movie search application which uses the TMDB API to fetch movie info and display it using a UICollectionView based on a user's search query.

Project Setup

Open up Xcode and create a new blank iOS App project – make sure you select UIKit and not SwiftUI.

In this app we are going to use the MVC Pattern so organise the project by creating the following groups and Swift files:

Now close your Xcode project. Open up the terminal and move to your project directory. Here we need to add SD WebImage Cocoa Pods to asynchronously download and cache the movie poster images.

Type the following command in the terminal:

pod init

Now when you list the contents of the directory, you can see that there is a new Podfile. Open the file using any text editor (here I've used Vim). Edit your Podfile so that it looks similar to the below image. Save and close the Podfile.

Now that we have specified the SD WebImage, we can install the dependencies by running the below command:

pod install

As you can see, we have successfully added the SD WebImage pod in our iOS project. Now run the below command to open our project in Xcode.

open PROJECT_NAME.xcworkspace

After opening Xcode, make sure you build your project by hitting Command+B.

How to Design the User Interface using UIKit and Programmatic UI

Our app needs three UIElements navigation bars to hold the search bar, UISearchBarController for actual search, and a UICollectionView to display the search results.

Open up your Scenedelegate.swift file and add the following code inside it which will connect to the session method:

func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
        guard let scene = (scene as? UIWindowScene) else { return }
        window = UIWindow(windowScene: scene)       window?.rootViewController=UINavigationController(rootViewController:HomeVC())
        window?.makeKeyAndVisible()
    }

Since we are using a programatic UI, first we need to mention our Root View controller – that is, the first screen which will be displayed when the user launches the app.

Here in this app we're using only one View Controller, so we wrap it inside a UINavigationController. This provides a navigation bar where we can place our UISearchController.

Open up the HomeVC.swift file and add the following properties:

 private var SearchBar: UISearchController = {
        let sb = UISearchController()
        sb.searchBar.placeholder = "Enter the movie name"
        sb.searchBar.searchBarStyle = .minimal
        return sb
    }()

    private var MovieCollectionView: UICollectionView = {
        let layout = UICollectionViewFlowLayout()
        layout.scrollDirection = .vertical
        layout.itemSize = CGSize(width: UIScreen.main.bounds.width/3 - 10, height: 200)
        let cv = UICollectionView(frame: .zero, collectionViewLayout: layout)
        cv.register(MovieCell.self, forCellWithReuseIdentifier: MovieCell.ID)
        return cv
    }()

First we create our UISearchController and configure its properties such as placeholder text and style.

Then we create a UICollectionView and specify the type of layout our collection view should use. In this case it is UICollectionViewFlowLayout and other properties such as scroll direction, item size, and specifying a custom CollectionView cell class which we will create later in our project.

Inside the HomeVC class create a new function and add the following code to configure auto-layout constraints programmatically for our UICollectionView:

    //MARK: - HELPERS
    func configureUI(){
        MovieCollectionView.translatesAutoresizingMaskIntoConstraints = false
        MovieCollectionView.topAnchor.constraint(equalTo: view.topAnchor).isActive = true
        MovieCollectionView.bottomAnchor.constraint(equalTo: view.bottomAnchor).isActive = true
        MovieCollectionView.leftAnchor.constraint(equalTo: view.leftAnchor).isActive = true
        MovieCollectionView.rightAnchor.constraint(equalTo: view.rightAnchor).isActive = true
    }

First we say that we don't need to convert the auto resizing mask into the constraints. Then we pin our collection view to all four sides of our View Controller.

Inside the viewDidLoad() method add the following lines of code:

  override func viewDidLoad() {
        super.viewDidLoad()

        navigationItem.title  = "Movie Search"
        view.backgroundColor = .systemBackground
        SearchBar.searchResultsUpdater = self
        navigationItem.searchController = SearchBar
        view.addSubview(MovieCollectionView)
        MovieCollectionView.delegate = self
        MovieCollectionView.dataSource = self
        configureUI()
    }

Here we first specify the title for our ViewController followed by the background color which is the systemBackground color. If the device is in light mode it shows a white background. If it is in dark mode, then it shows a dark background.

Then we set current the view controller as the search result updater, then add our SearchController to the navigation bar, add the UICollectionView to the ViewController, and setup delegate and datasource. Finally we pin the UICollectionView by using auto-layout.

Create an extension for HomeVC and implement the UISearchResultsUpdating protocol and its stub method updateSearchResults.

extension HomeVC: UISearchResultsUpdating{

    func updateSearchResults(for searchController: UISearchController) {
        guard let query = searchController.searchBar.text else{return}

        }

    }


}

The updateSearchResults() method will be called whenever the text entered in the search bar changes or when the user taps the search button on their keyboard.

Next we need to create that custom UICollectionView cell. Inside the MovieCell.swift file, add the following code:

import Foundation
import UIKit
import SDWebImage

class MovieCell: UICollectionViewCell{

    static let ID = "MovieCell"
    private var MoviePosterImageView: UIImageView = {
        let imageView = UIImageView()
        imageView.contentMode = .scaleAspectFit
      //  imageView.image = UIImage(systemName: "house")
        return imageView
    }()

    override init(frame: CGRect) {
        super.init(frame: frame)
        addSubview(MoviePosterImageView)
        configureUI()
    }

    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

}

extension MovieCell{
    func configureUI(){
        MoviePosterImageView.translatesAutoresizingMaskIntoConstraints = false
        MoviePosterImageView.topAnchor.constraint(equalTo: topAnchor).isActive = true
        MoviePosterImageView.bottomAnchor.constraint(equalTo: bottomAnchor).isActive = true
        MoviePosterImageView.leftAnchor.constraint(equalTo: leftAnchor).isActive = true
        MoviePosterImageView.rightAnchor.constraint(equalTo: rightAnchor).isActive = true
    }
    func updateCell(posterURL: String?){
        if let posterURL = posterURL {
            guard let CompleteURL = URL(string: "https://image.tmdb.org/t/p/w500/\(posterURL)") else {return}
            self.MoviePosterImageView.sd_setImage(with: CompleteURL)
        }

    }
}

Here we create our custom collection view cell by sub-classing the UICollectionView class and implementing the init() functions.

We create a UIImageView to display the movie poster image and setup auto-layout constraints for it. Then we create a user defined function which takes the Movie poster URL string a parameter and downloads it asynchronously without affecting the UI Thread/Main thread. It does this by using the SD WebImage CocoaPod which we added earlier.

How to Set Up Our API

Before moving on, you'll need to get your API key for the TMDB API by creating an account (it's free). We are going to use the Movie Search end point of the API which takes the API Key and movie name as parameters.

https://api.themoviedb.org/3/search/movie?api_key=API_KEY_HERE&query=batman

You can examine the API response by running it in Postman.

How to Create a Model for the API Response

Now we get a JSON response from the API. We need to decode them to Swift which we can do by creating a model struct that implements the Codable protocol.

WE can generate the model struct for our JSON response easily by using JSON to Swift websites. Here is the model code for the API response – you can just copy and paste it inside the Model.swift file:

import Foundation

struct TrendingTitleResponse: Codable {
    let results: [Title]
}

struct Title: Codable {
    let id: Int
    let media_type: String?
    let original_name: String?
    let original_title: String?
    let poster_path: String?
    let overview: String?
    let vote_count: Int
    let release_date: String?
    let vote_average: Double
}

struct YoutubeSearchResponse: Codable {
    let items: [VideoElement]
}


struct VideoElement: Codable {
    let id: IdVideoElement
}


struct IdVideoElement: Codable {
    let kind: String
    let videoId: String
}

How to Perform HTTP Requests Using Swift

Now we need to write some Swift code to perform HTTP GET requests which return the JSON response of the API.

Swift provides a URLSession class which makes it easier to write networking code without needing any third party libraries like AFNetworking, AlamoFire, and so on.

Open APIService.swift and add the following code:

import Foundation

class APIService{
    static var shared = APIService()
    let session = URLSession(configuration: .default)

    func getMovies(for Query: String,completion:@escaping([Title]?,Error?)->Void){
        guard let FormatedQuery = Query.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed)  else{return}

        guard let  SEARCH_URL = URL(string: "https://api.themoviedb.org/3/search/movie?api_key=API_KEY_HERE&query=\(FormatedQuery)") else {print("INVALID")
            return}



        let task = session.dataTask(with: SEARCH_URL) { data, response, error in
            if let error = error {
                print(error.localizedDescription)
                completion(nil,error)
            }
            if let data = data {
                do{
                    let decodedData = try JSONDecoder().decode(TrendingTitleResponse.self, from: data)
                 //   print(decodedData)
                    completion(decodedData.results,nil)
                }
                catch{
                    print(error)
                }
            }
        }
        task.resume()
    }
}

Here we created a class named API Service with the singleton pattern so we need an instance for this class as a static member of the class. Then we created a session for our networking task with the default configuration, followed by a user defined method getMovies().

Then we created our networking task – in this case we need to perform HTTP GET requests which can be performed using the dataTask() method of the URLSession class. It takes the URL as a parameter and gives a completion handler which contains data returned from the API, error data if any error has occurred, and a response which has HTTP Response information such as status codes and their corresponding messages.

If there is any error, then we escape out of this function with error data. If not, then we decode our JSON data based on our Swift Model and escape out of this function with the decoded data.

How to Display the Search Results on the UICollectionView

In HomeVC.swift, create a private property which is an array of Title objects. These will hold each movie's info returned by the API.

private var Movies = [Title]()

In HomeVC.swift create an extension for the HomeVC class and implement the UIColletionViewDelegate and UICollectionViewDatasource protocols. Then implement numberOfItemsInSection (which is equal to the number of movies returned by the API) and cellForItemAt (which actually populates the cell with API responses, like download and set the poster image).

 func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
        return Movies.count
    }
    func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
        if let cell = collectionView.dequeueReusableCell(withReuseIdentifier: MovieCell.ID, for: indexPath) as? MovieCell{
           // cell.backgroundColor = .systemBackground

            cell.updateCell(posterURL: Movies[indexPath.row].poster_path)
            return cell
        }
        return UICollectionViewCell()

    }

Finally we need to make actual API call which we do inside the updateSearchResults() delegate method which we have implemented previously. Inside that method add the following code:

    func updateSearchResults(for searchController: UISearchController) {
        guard let query = searchController.searchBar.text else{return}
        APIService.shared.getMovies(for:query.trimmingCharacters(in: .whitespaces)) { titles, error in
            if let titles = titles {
                self.Movies = titles
                DispatchQueue.main.async {
                    self.MovieCollectionView.reloadData()
                }

            }
        }

    }

Here, whenever the user types in the search bar or presses the search button, we make an HTTP GET request to fetch a movie (based on the name entered in the search bar). Then we reload the CollectionView which updates the collection view cells with the movie poster.

Note that we need to do this in the Main Thread/UI Thread, because by default iOS automatically makes HTTP request in background thread. This means that we need to use UI/Main Thread to update our UI elements.

Now run your app in the simulator to see the result:

Congratulations! You have learned to use UISearchController in iOS apps.

Hello, everyone! In this article we are going to learn how to add the Realm database to an iOS app.

We'll create a simple ToDo app so you can learn how to perform CRUD (Create, Read, Update, Delete) operations in the Realm database.

What is Realm?

Realm is an open-source mobile database which is developer friendly and easy to use. You can also use it as an alternative to Core Data in iOS apps.

Realm is a cross platform mobile database, which means that you can use it in native Android and iOS apps and also in cross platform apps like those created using React Native. It supports Objective-C, Swift, Java, Kotlin, C#, and JavaScript.

How to Set Up Realm in Your iOS Project

We can add Realm to our iOS project using SPM (the Swift Package Manager), Cocoa Pods, or Carthage. Here, we are going to use Cocoa Pods to add Realm Pod to our iOS project.

1. Open up Xcode and create a blank iOS app project with UIKit and Swift without using Core Data.
2. Now close Xcode and open up the terminal. Navigate to your project directory using the terminal.
3. Run the following command to create a PodFile.

pod init

4. Now when you list the contents of the directory you can see that there is a new Podfile. Open the file using any text editor (here I've used Vim). Edit your Podfile so that it looks similar to the below image. Save and close the Podfile.

Now that we have specified the dependence for Realm DB, we can install the dependencies by running the below command:

pod install

As you can see, we have successfully added the Realm DB dependency in our iOS project. Now run the below command to open our project in Xcode.

open YOUR_APP_NAME.xcworkspace

Note: after opening Xcode, make sure you build your project by pressing Command+B.

How to Design Your User Interface in Realm

We are going to keep our app's UI simple. Open up Main.storyboard and create a simple UI as shown below by adding a table view with a prototype cell. Then embed a navigation controller and create the IBOutlets for the tableview in the ViewController.swift file:

How to Create a Data Model in Realm

In our ToDo app, each task has a task name and a task id. We are going to create a Model class to represent the todo task. In the project navigator right click and create a new Swift file, and add the below code.

import Foundation
import RealmSwift


class ToDoTask:Object
{
    @objc dynamic var tasknote: String?
    @objc dynamic var taskid: String?
}

Her we created our model class named ToDoTask. It inherits the Object class which is a class that comes with RealmDB. This class handles all the under the hood processes of saving the data created using this model class in the database.

We also added two properties: tasknote, which is the task to be done, and taskid – both of type string. @objc means that your Swift code is visible to Objective C and dynamic means you want to use Objective C dynamic dispatch.

Basic CRUD App functions

Our app will perform the following functions:

1. Get input from the user using AlertViewController.
2. Add the input to the database and also to the table view.
3. Allow the user to edit their input.
4. Swipe to delete a row to remove the data from both the table view and the database.
5. Fetch all the data (if present) from the database and display it in the table view.

How to get input from the user using AlertViewController

Open up ViewController.swift and add the below code inside the ViewDidLoad() method. And create a new function called addTask() and add the code to display the alert view controller with a text box to get input from the user.

Now when the right bar button is pressed it will call the addTask() function which will display the alertviewcontroller with a text field to get user input.

navigationItem.rightBarButtonItem = UIBarButtonItem(image: .add, style: .done, target: self, action: #selector(addTask))

navigationController?.navigationBar.prefersLargeTitles = true

title = "RealmDB"

@objc
    func addTask()
    { 
        let ac = UIAlertController(title: "Add Note", message: nil, preferredStyle: .alert)

        ac.addTextField(configurationHandler: .none)

        ac.addAction(UIAlertAction(title: "Add", style: .default, handler: { (UIAlertAction) in

              if let text = ac.textFields?.first?.text
            {
                print(text)
            }

        }))
        ac.addAction(UIAlertAction(title: "Cancel", style: .cancel, handler: nil))
        present(ac, animated: true, completion: nil)
    }

How to add the input to the database and table view

To save data into Realm, first we need obtain an instance for Realm through which we can access all the methods needed for CRUD operations. Create a property of type Realm in the ViewController.swift file and initialise it in the viewDidLoad() method.

 var realmDB: Realm!

 override func viewDidLoad() {
        super.viewDidLoad()

        navigationItem.rightBarButtonItem = UIBarButtonItem(image: .add, style: .done, target: self, action: #selector(addTask))
        navigationController?.navigationBar.prefersLargeTitles = true
        title = "RealmDB"

        realmDB = try! Realm()

    }

Create an empty array of type our DataModel (ToDoTask). This array will hold all the tasks which need to be added to the table view and database.

Now inside the addTask() function modify the Add action closure so that it gets the user input and creates a random ID for that input. Then append it to our array and save it to the database.

var tasks = [ToDoTask]()

 if let text = ac.textFields?.first?.text
            {
                //Add data to data model array
                let t = ToDoTask()
                t.taskid = UUID().uuidString
                t.tasknote = text
                self.tasks.append(t)

                //Add data to database
                try! self.realmDB.write {
                    self.realmDB.add(t)
                }
                //Update table view UI
                self.tasktv.reloadData()
            }

Now when you run the app, the data will be saved in the database. But it will not show in table view because we have not implemented the delegate methods.

Make the ViewController class implement the UITableViewDelegate and UITableViewDataSource protocols and add the protocol stubs.

Now inside the numberOfRowsInSection method, return the count of our tasks array which gives the number of rows to be added to the table view. This is equal to the number of elements in tasks array.

 func tableView(_ tableView: UITableView, numberOfRowsInSection section: 
 Int) -> Int 
 {
        return tasks.count;
 }

The next thing we need to do is specify the content in each row. We can do this using the cellForRowAt delegate method. Here we dequeue a cell using the identifier which we have mentioned in storyboard and specify the label text as the tasks array element tasknote property.

 func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        if let cell = tableView.dequeueReusableCell(withIdentifier: "cell")
        {
            cell.textLabel?.text = tasks[indexPath.row].tasknote
            return cell
        }
        return UITableViewCell()
    }

How to allow users to edit their input

Now we have to allow the user to edit their entered tasks and update the changes in both the database and UI. We can do this using similar methods of getting input from the user. Implement the didSelectRowAt delegate method which will be called when user taps the table view row.

Add the below code which displays an AlertViewController with a text view. Then update the content of the cell with the entered text, and at the same time update the database contents.

func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {

        let tasktomodify = tasks[indexPath.row]
        let ac = UIAlertController(title: "Update task", message: nil, preferredStyle: .alert)

        ac.addTextField(configurationHandler: .none)
        ac.addAction(UIAlertAction(title: "Ok", style: .default, handler: { (UIAlertAction) in
            if let text = ac.textFields?.first?.text
            {
                if(!text.isEmpty)
                {
                try! self.realmDB.write({
                    tasktomodify.tasknote = text
                })
                self.tasktv.reloadData()
                }
            }
        }))

        present(ac, animated: true, completion: nil)
    }

How to swipe to delete a row & remove the data from both the table view and database

Here we are going to implement a swipe to delete feature in our table view so that users can delete their tasks. But under the hood when the user swipe deletes a table view row then it should delete the data from database, data model array, and update the UI of the table view.

We can do this by implementing the commit editingStyle delegate method and adding the following code:

 func tableView(_ tableView: UITableView, commit editingStyle: UITableViewCell.EditingStyle, forRowAt indexPath: IndexPath) {
        if editingStyle == .delete
        {
            let tasktoDelete = tasks[indexPath.row]
            try! realmDB.write({
                realmDB.delete(tasktoDelete)
                self.tasks.remove(at: indexPath.row)
                self.tasktv.deleteRows(at: [indexPath], with: .fade)
            })
        }
    }

How to fetch all the data (if present) from the database and display it in the table view

Now we are going to implement our last operation, Read. Whenever the user launches the app, it should fetch data from the database (if data is present) and display it in the table view.

We can do this by creating a function getTodo in the view controller swift file and adding the following code inside it:

func getTodos()
    {
       //Get all the data from the database
        let notes = realmDB.objects(ToDoTask.self)

        //Clear the model data array to prevent duplicates
        self.tasks.removeAll()

        /*If the fetched data is not empty then add it to model data array and update the UI */
        if(!notes.isEmpty)
        {
        for n in notes
        {

            self.tasks.append(n)

        }
            self.tasktv.reloadData()
        }


    }

Bonus Tip: How to View Your Database Content in an iOS Simulator

Now when you run your app, you can see that it works as expected. But how can we check if the data is really stored in the database? We can use an app called MongoDB Realm Studio through which we can view our data stored in the Realm database of the simulator.

Note that this method works only when you test the app using iOS simulator

In the viewDidLoad() method, add the below line of code which will print the real file path of our app:

 print(realmDB.configuration.fileURL!)

Now copy the file path printed in the console, open up the terminal, and run the following command:

open REALM_FILE_PATH_HERE

Make sure you have downloaded MongoDB Realm Studio from the browser before running the above command.

Now it will open the RealmFile of the app in MongoDB Realm Studio. This will display the data stored in the database in a table format.

If you make changes to your data by editing or deleting the task, the changes will be reflected in the MongoDB Realm Studio app:

Congratulations! You have made a simple app which implements CRUD operations in iOS apps.

The article will teach you how you can show multiple videos in one view, like we see in Instagram Stories.

We'll also learn how to cache the videos in the user's device to help save that user's data and network calls and smooth out their experience.

A quick note: this implementation is for iOS, but the same logic can be applied in other codebases as well.

In general, whenever we want to play a video, we get the video URL and simply present **AVPlayerViewController** with that URL.

let videoURL = URL(string: "Sample-Video-Url")
let player = AVPlayer(url: videoURL!)
let playerViewController = AVPlayerViewController()
playerViewController.player = player
self.present(playerViewController, animated: true) {
    playerViewController.player.play()
}

Pretty straightforward, right?

But the drawback of this implementation is that you can’t customize it. Which, if you are working for a good product company, will be an everyday ask. :D

Alternatively, we can use **AVPlayerLayer** which will do a similar job – but it allows us to customize the view and other elements.

let videoURL = URL(string: "Sample-Video-Url")
let player = AVPlayer(url: videoURL!)
let playerLayer = AVPlayerLayer(player: player)
playerLayer.frame = self.view.bounds
self.view.layer.addSublayer(playerLayer)
player.play()

But what if you want to combine multiple videos, similar to Instagram stories? Then we probably have to dive in a bit deeper.

Coming Back to the Problem Statement

Now, let me tell you about my use case.

In my company, Swiggy, we want to be able to show multiple videos, where each video should be shown x number of times.

On top of that, it should have an Instagram-like stories feature.

• Video-2 should seamlessly autoplay after video-1, and so on
• It should jump to corresponding videos whenever the user taps left or right.

If you think caching could be the answer, don't worry – I’ll get to that in a bit.

Multiple layers in one view

First things first, we need to figure out how to add multiple videos in one view.

What we can do is create one **AVPlayerLayer** and assign the first video to it. When the first video is finished, then we assign the next video to the same **AVPlayerLayer** .

func addPlayer(player: AVPlayer) {
    player.currentItem?.seek(to: CMTime.zero, completionHandler: nil)
    playerViewModel?.player = player
    playerView.playerLayer.player = player
}

To jump to the previous or next video, we can do the following:

• Add a tap gesture on the view
• If the touch location ‘x’ is less than half of the screen, then assign the previous video, else assign the next video

@objc func didTapSnap(_ sender: UITapGestureRecognizer) {
   let touchLocation = sender.location(ofTouch: 0, in: view)
   if touchLocation.x < view.frame.width/2 {
     changePlayer(forward: false)
     } 
   else {
     fillupLastPlayedSnap()
     changePlayer(forward: true)
    }
}

There we go. We now have our own Insta-like Stories video feature.

But our task is not done yet!

Now Back to Caching

We don't want it to be the case that every time a user navigates from one video to another, it starts to download the video from the beginning.

Also, if the video is shown again in the next session, we don't need to do another server call.

If we can cache the video, then the user’s internet will be saved. The load on the server will also be reduced.

Finally, the UX will improve as the user won't have to wait a long time to load the video.

As a good developer, reducing a user’s internet usage should be our priority.

Less data usage, happy customer

Load Videos Asynchronously

The first thing we can use to load videos is loadValuesAsynchronously.

According to the Apple documentation, loadValuesAsynchronously:

Tells the asset to load the values of all of the specified keys (property names) that are not already loaded.

The advantage here is that it saves the video until it is rendered. So it will not download the video from the start whenever the user navigates to a previous video. It will only download the part which was not rendered earlier.

Let's look at an example**: say we have Video_1 that is 15 seconds long, and the user saw 10 seconds of that video before jumping to Video_2.

Now if the user comes back to Video_1 again by tapping to the left, loadValuesAsynchronously will have that 10 seconds of video saved and will only download the remaining (unwatched) 5 seconds.

func asynchronouslyLoadURLAssets(_ newAsset: AVURLAsset) {
    DispatchQueue.main.async {
            newAsset.loadValuesAsynchronously(forKeys: self.assetKeysRequiredToPlay) {
                for key in self.assetKeysRequiredToPlay {
                    var error: NSError?
                    if newAsset.statusOfValue(forKey: key, error: &error) == .failed {
                        self.delegate?.playerDidFailToPlay(message: "Can't use this AVAsset because one of it's keys failed to load")
                        return
                    }
                }

                if !newAsset.isPlayable || newAsset.hasProtectedContent {
                    self.delegate?.playerDidFailToPlay(message: "Can't use this AVAsset because it isn't playable or has protected content")
                    return
                }
                let currentItem = AVPlayerItem(asset: newAsset)
                let currentPlayer = AVPlayer(playerItem: currentItem)
                self.delegate?.playerDidSuccesToPlay(playerDetail: currentPlayer)
            }

        }

You can find more details on loadValuesAsynchronously at this link.

The caveat here is it persists video data for that session only. If the user closes and comes back to the app, the video has to be downloaded again.

So what other options do we have?

Saving Videos in Device

Now comes Video Caching!

When the video is rendered completely, we can export the video and save it to the user’s device. When the video comes up again in their next session, we can pick the video from the device and simply load it.

AVAssetExportSession
According to Apple's documentation:

An object that transcodes the contents of an asset source object to create an output of the form described by a specified export preset.

This means that AVAssetExportSession acts as an exporter, through which we can save the file to the user’s device. We have to give the output URL and the output file type.

let exporter = AVAssetExportSession(asset: avUrlAsset, presetName: AVAssetExportPresetHighestQuality)
exporter?.outputURL = outputURL
exporter?.outputFileType = AVFileType.mp4

exporter?.exportAsynchronously(completionHandler: {
    print(exporter?.status.rawValue)
    print(exporter?.error)
})

You can find more details on AVAssetExportSession at this link.

Now the only thing left is to fetch the data from the cache and load the video.

Before loading, check if the video is present in the cache. Then fetch that local URL and give it to loadValuesAsynchronously.

if let cacheUrl = FindCachedVideoURL(forVideoId: videoId) {
    let cacheAsset = AVURLAsset(url: cacheUrl)
    asynchronouslyLoadURLAssets(cacheAsset)
}
else {
  asynchronouslyLoadURLAssets(newAsset)
}

Caching will help reduce a lot of user data usage as well as server load (sometimes up to TBs of data).

Other use cases for caching

What other use cases we can handle with caching? The following are examples of ways you could use caching here:

Ensure Optimum Storage

Before saving the video on the device, you should check whether enough storage is present on the device to do so.

func isStorageAvailable() -> Bool {
   let fileURL = URL(fileURLWithPath: NSHomeDirectory() as String)
   do {
      let values = try fileURL.resourceValues(forKeys: [.volumeAvailableCapacityForImportantUsageKey, .volumeTotalCapacityKey])
      guard let totalSpace = values.volumeTotalCapacity,
      let freeSpace = values.volumeAvailableCapacityForImportantUsage else {
          return false
      }
      if freeSpace > minimumSpaceRequired {
         return true
      } else {
          // Capacity is unavailable
          return false
      }  
    catch {}
    return false
}

Remove Deprecated Videos

You can have a timestamp for each video so that you can clean up old videos from device memory after a certain number of days.

func cleanExpiredVideos() {
        let currentTimeStamp = Date().timeIntervalSince1970
        var expiredKeys: [String] = []
        for videoData in videosDict where currentTimeStamp - videoData.value.timeStamp >= expiryTime {
            // video is expired. delete
            if let _ = popupVideosDict[videoData.key] {
                expiredKeys.append(videoData.key)
            }
        }
        for key in expiredKeys {
            if let _ = popupVideosDict[key] {
                popupVideosDict.removeValue(forKey: key)
                deleteVideo(ForVideoId: key)
            }
        }
    }

Maintain a limited number of videos

You can make sure only a limited number of videos are saved in the file at a time. Let's say 10.

Then when the 11th video comes, you can have it delete the least-viewed video and replace it with the new one. This will also help you not consume too much of the user’s device memory.

func removeVideoIfMaxNumberOfVideosReached() {
        if popupVideosDict.count >= maxVideosAllowed {
            // remove the least recently used video
            let sortedDict = popupVideosDict.keysSortedByValue { (v1, v2) -> Bool in
                v1.timeStamp < v2.timeStamp
            }
            guard let videoId = sortedDict.first else {
                return
            }
            popupVideosDict.removeValue(forKey: videoId)
            deleteVideo(ForVideoId: videoId)
        }
    }

Measure Impact

Don’t forget to add logs, so that you can measure the impact of your feature. I have used a custom New Relic Log Event to do so:

 static func findCachedVideoURL(forVideoId id: String) -> URL? {
        let nsDocumentDirectory = FileManager.SearchPathDirectory.documentDirectory
        let nsUserDomainMask = FileManager.SearchPathDomainMask.userDomainMask
        let paths = NSSearchPathForDirectoriesInDomains(nsDocumentDirectory, nsUserDomainMask, true)
        if let dirPath = paths.first {
            let fileURL = URL(fileURLWithPath: dirPath).appendingPathComponent(folderPath).appendingPathComponent(id + ".mp4")
            let filePath = fileURL.path
            let fileManager = FileManager.default
            if fileManager.fileExists(atPath: filePath) {
                NewRelicService.sendCustomEvent(with: NewRelicEventType.statusCodes,
                                                                   eventName: NewRelicEventName.videoCacheHit,
                                                                   attributes: [NewRelicAttributeKey.videoSize: fileURL.fileSizeString])
                return fileURL
            } else {
                return nil
            }
        }
        return nil
    }

To convert the file size to a readable format, I fetch the file size and convert it to Mbs.

extension URL {
    var attributes: [FileAttributeKey : Any]? {
        do {
            return try FileManager.default.attributesOfItem(atPath: path)
        } catch let error as NSError {
            print("FileAttribute error: \(error)")
        }
        return nil
    }

    var fileSize: UInt64 {
        return attributes?[.size] as? UInt64 ?? UInt64(0)
    }

    var fileSizeString: String {
        return ByteCountFormatter.string(fromByteCount: Int64(fileSize), countStyle: .file)
    }
}

This is how you can measure your impact:

Total data saved = number of requests video_size = 2.4MB20.3K ~= 49GB

This is just two weeks of data. You do the math for the whole year. ? And this will keep on increasing exponentially over time.

That’s it! You have now built your own caching mechanism.

Wrapping up

In this article, we saw how easily we can integrate multiple videos in one view, giving an Instagram-like story feature.

We also learned why and how caching plays an important role here. We saw how it helps the user save a lot of data and have a smooth user experience.

Do let me know if I missed something, or if you can think of any more use cases.
Thanks for your time. :)

With the release of iOS14, there have been major changes in the way applications can gather information about a user. One of them deals with the Identifier For Advertisers (or IDFA) and how applications can access it.

But for those that don't know, let's first explain what the IDFA is and why it's important.

What is an IDFA?

Each iOS device owner can decide whether they want to be tracked by advertising companies. This allows those companies to supplying that user with content that is tailored towards them (based on their online browsing habits).

Companies can do this with what’s known as an IDFA (Identifier For Advertisers). This is a [UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier#:~:text=A%20universally%20unique%20identifier%20(UUID,%2C%20for%20practical%20purposes%2C%20unique.) string that lets advertisers match the user with their behavior.

Here's an example of a UUID string : 123e4567-e89b-12d3-a456–426614174000.

So, what are those changes we talked about earlier?

In short, applications will now be required to show a dialog to the user, asking them if they want to allow the application to track them or not.

The Tracking Authorization Dialog

Looks pretty ominous, right?

This is in contrast with how things worked before iOS14, where you only had to check if the device had limited advertising tracking enabled or disabled.

The newest version of Apple’s operating system (iOS14) is already available (has been since September 16th). Developers who use the IDFA have to make changes in their applications in order to be compatible for iOS14.

On September 3rd, Apple made an update and pushed the deadline to complete these updates to the start of next year:

“To give developers time to make necessary changes, apps will be required to obtain permission to track users starting early next year”

Now that we have some time to regain our composure and breathe again, let’s start preparing ourselves for what’s going to be the new normal in 2021.

In this article, we'll present some background about the IDFA and see how we can get its value from iOS14 and onwards.

How does the IDFA Get Used By Advertisers?

Let’s take a scenario (pre COIVD-19) where you are browsing the web on your iPhone and are looking for a hotel for your next vacation.

Each ad that you see will send a pixel with your IDFA attached to it. An advertiser can see that you are looking at a lot of ads promoting hotels by matching your IDFA and conclude that you are looking to book a hotel room.

From there, it won’t be long until you will be shown a lot of ads for hotel rooms.

This simple yet profound technology came into our lives back in 2012 with iOS6. Since then a lot has changed, and iOS14 is flipping the industry on its head, yet again.

✋ Note: To use these new APIs you must have upgraded/downloaded XCode 12.

Advertising Tracking And Getting The IDFA

Before iOS14, getting the IDFA was pretty simple.

You had to check whether Advertising Tracking was enabled or not, by doing this:

[[ASIdentifierManager sharedManager] isAdvertisingTrackingEnabled]

And if it was disabled, that meant you could acquire the IDFA through the ASIdentifierManager class, like so:

[[[ASIdentifierManager sharedManager] advertisingIdentifier] UUIDString];

Simple enough, right?

☝️ Beginning with iOS10, if the user disabled advertising tracking, the method above would return a UUID string filled with zeros.

One of the changes in iOS14 is the deprecation of the method that checks whether advertiser tracking is enabled or not. So how can applications get the coveted IDFA from iOS14 and onward?

They will have to use a new API that presents a dialog to the user. A few words of wisdom regarding this dialog:

• It can only be presented to the user once
• The only thing that can be altered in the dialog’s UI are the two lines above the Allow Tracking option (“Do you want to be tracked?”)

This means that developers will need to think long and hard about how and when they will present the message to the user.

Authorization Status

With iOS14, a new framework has been created called App Tracking Transparency. This framework contains a class called ATTrackingManager, which provides an API to:

1. Present a dialog to the user requesting permission to track them
2. Query the authorization status (regardless of showing or not showing the dialog)

We’ll first learn how to get the authorization status. To do so, you need to call the trackingAuthorizationStatus method.

ATTrackingManagerAuthorizationStatus status = [ATTrackingManager trackingAuthorizationStatus];

It will return an NSUInteger with one of the following values:

• ATTrackingManagerAuthorizationStatusNotDetermined = 0
• ATTrackingManagerAuthorizationStatusRestricted = 1
• ATTrackingManagerAuthorizationStatusAuthorized = 3
• ATTrackingManagerAuthorizationStatusDenied = 2

The first three results are pretty self explanatory, so we will focus for a minute on the last one.

You can get an authorization status that is restricted when the screen for enabling/disabling advertising tracking is locked and this option is set to enabled.

Apple has acknowledged this in devices that are identified as belonging to children (for example).

Asking For Permission To Track

Before looking into the code needed to present the dialog, you must first include the NSUserTrackingUsageDescription key inside your info.plist file.

What you add as the value for this key will appear as the two lines mentioned earlier, in the dialog.

NSUserTrackingUsageDescription in the info.plist file

To present the dialog, we need to call requestTrackingAuthorizationWithCompletionHandler:

[ATTrackingManager requestTrackingAuthorizationWithCompletionHandler:^(ATTrackingManagerAuthorizationStatus status) {
        if (status == ATTrackingManagerAuthorizationStatusDenied) {
            //Logic when authorization status is denied
        } else if (status == ATTrackingManagerAuthorizationStatusAuthorized) {
            //Logic when authorization status is authorized
        } else if (status == ATTrackingManagerAuthorizationStatusNotDetermined) {
            //Logic when authorization status is unknown
        }  else if (status == ATTrackingManagerAuthorizationStatusRestricted) {
            //Logic when authorization status is restricted
        }
    }];

In the first picture of this article (where you see the dialog) you can see that the lines we wrote in the info.plist file show up as the two lines in the dialog.

Wrapping up

In conclusion, it's important to remember that these changes, while daunting, are not happening immediately.

You should also make sure to follow all of the steps detailed in this article so as not to come across crashes/errors in your applications.

Technology has always brought something new with time. And with these ever-changing technologies, you need to stay updated to get all the benefits from what's new.

Also, when we talk about technology, one of the first things that probably comes to our minds is mobile phones and mobile applications. We are also well aware of the name and fame of iOS devices. And as we've learned from a report from Above Avalon, the number of i-Phones in the wild likely now exceeds 925 million.

Now, it's time to look at the top iOS app development trends in 2020. We should take a deep dive into iOS mobile app development trends because iOS has become one of the leading development platforms in the market in recent years. iOS is also supposed to be safer than any other operating system.

We can see all this in these stats from Statista.com:

These statistics show the cumulative Apple App Store earnings of mobile app developers as of January 2020. As of the last reported period, Apple had paid a total of 155 billion U.S. dollars to iOS app developers. A year ago, this figure amounted to 120 billion U.S. dollars.

According to Goodworklabs.com, with an 18% market share and a combined share of 99.6% with Android, Apple’s iOS is one of the most happening operating systems of the world.

Well, after going through the various stats and facts, it's time to jump into different trends to watch for iOS app development in 2020.

Improved app security

Security features are one of the most helpful and important trends of iOS mobile app development. You might all be aware of Apple's security algorithms. Indeed the company is famous for its hardcore security layers and highly secure policies which help to stop hacks into Apple devices.

Given the number of hacking attacks these days, one mistake can destroy everything. And Apple has around 1.4 billion active devices.

Forbes published an article titled “iPhone Hack: Google Warns 1 Billion Apple Users They May Have Been Attacked” on 30th Aug 2019. This was just before the launch of iPhone 11 and almost every iOS device was found vulnerable. The vulnerability was fixed in the latest iOS updates.

According to one statement by Phil Schiller, the Senior Vice President of Worldwide Marketing at Apple Inc,

“(Apple is) helping to protect our children from technologies that could be used to violate their privacy and security.”

This sheds some light on potential security loopholes. And to help close them, Apple has initiated an enterprise-wide culture that caters to the user’s need to create a safe environment. So their aim is to help improve overall security as well as prevent cyber-attacks and data breaches.

Let’s talk about password auto-fill, for example. Did you know that Apple has deployed ASWebAuthentication Sessions which help coordinate cookies and website data for signing in? With this, the device is able to use the authentication service's frameworks in order to incorporate password manager apps.

Cloud Integrated iOS Apps

Cloud technology has brought a revolution to the tech space as well as many opportunities. With the help of cloud technology, organisations can store vast amounts of data in the cloud without any fear of using too much data space.

Because of this, most iOS apps are now built on cloud technology as this is one of the most trustworthy platforms where you can store data. You can also access it anywhere with full security, quickly and easily.

You've probably heard about "iCloud" services. This allows iOS device users to store their content without worrying about space. Content stored in iCloud includes stuff like images, files, notes, and much more.

iCloud can be accessed on any device with your login id and password. According to Wikipedia, 850 million people trust iCloud.

A significant advantage of having cloud-based apps is that they do not need any physical space in your system, as you can run your data directly on the cloud.

The cloud helps enhance and extend the internal memory of your smart devices. This major feature of cloud-based apps helps increase productivity and collaboration with mobile apps.

This trend is going to revolutionise app development in the coming years.

Enterprise Development

Enterprise development is one of the most essential and primary parts of many businesses, and this is why most of the developers prefer to build Enterprise software through iOS.

Enterprise development should be done in a customised way so that the user can get all the benefits. It provides the best user experience, improved security, and high productivity.

This is why most iOS developers trust iOS because it is useful in scalable enterprise development.

Source: The Verge

Swift 5 Programming Language

The Swift 5 programming language has become quite trendy. Apple has released it with a stable Application Binary Interface (ABI) and binary compatibility.

In addition to ABI, Swift 5 has raw strings, future enum cases, a result type, checking for integer multiples and a lot more. Now iOS app development companies are focusing on using Swift to the best of its abilities for optimal business impact.

Source: 9to5Mac

According to Reddit, “Of the top 110 apps on the app store, 42% are using Swift. If you ignore games, then 57% of the apps are using Swift.”

Swift libraries will be incorporated into every future macOS, iOS, Wearable OS, and TVOS device.

Swift 5 is source compatible with Swift 4, Swift 4.1 and Swift 4.2, as well as with X code 10.2. It has a code migration that is designed to handle some of the necessary source changes automatically.

One of the significant advantages of this software is that it is highly compatible with Linux, so it will be easy for developers to increase their knowledge base for Swift 5 when designing apps.

IoT Focused Apps

There is no doubt that the internet of things has become part of day to day life, so there is no need to introduce it. This technology is becoming more well-known by the day among developers worldwide.

The Internet of Things is a source of communication between you and your smart device. This is why it is creating a revolution.

Today developers are more focused on building iOS apps that, for example, can connect to internet-enabled devices. So we could say that IoT has helped developers create exceptional offerings for users by embedding better connection facilities in their apps.

There is no doubt that IoT is going to revolutionise the technical world. This is why iOS developers should use this technology as their main tool. It is definitely beneficial and makes things easier for end-users.

Let’s look at an example: pharmaceutical companies use IoT devices to help develop temperature monitoring apps. These apps can detect whether temperatures for certain processes (as desired for the same) do not exceed the allowed limits. So, there are many fields where IoT is leaving its impact with great positivity.

Globally, the number of IoT devices that are active is expected to grow to 10 billion by 2020 and 22 billion by 2025, says IOT-analytics.com

Final words

Well, on the basis of this information, you can now see that the above-mentioned iOS app development trends are going to rule 2020. So you should definitely not forget these trends while working on your iOS apps this year.

If you still have questions you can explore this vast topic more. Otherwise, you can leave a comment to let me know how this article helped you.

A related interesting read: Top Mobile App Trends For 2020

In this post we will try to re-create the Spotify home screen layout in Swift programmatically. Why programmatically? I think it's always good to know how to build things in different ways, and I like to write code to do things programmatically. These skills are especially helpful if you are working with team or using version control.

This is the actual home screen of Spotify's mobile app. So to achieve this kind of layout, we will be using UICollectionView, and we may use TabBarController as well to create the tab navigator.

Basic requirement : First make sure you have Xcode +10 installed and swift +4.

Let's start by creating a new Xcode project using Xcode:

And the first thing we need to do in ViewController.swift is change the superClass to UICollectionViewController instead of UIViewController because our class will be based on collectionView.

//
//  ViewController.swift
//  spotifyAutoLayout
//
//  Created by admin on 10/31/19.
//  Copyright © 2019 Said Hayani. All rights reserved.
//

import UIKit

class ViewController: UICollectionViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        collectionView.backgroundColor = .purple
        // Do any additional setup after loading the view.
    }


}

If you try to run the app the build will fail. We need to add some code to the AppDelegate.swift file within the didFinishLaunchingWithOptions function past this piece of code before the return statement:

  let layout = UICollectionViewFlowLayout()
        window = UIWindow()
        window?.rootViewController = ViewController(collectionViewLayout: layout)

And the code should look like this:

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        let layout = UICollectionViewFlowLayout()
        window = UIWindow()
        window?.rootViewController = ViewController(collectionViewLayout: layout)
        return true
    }

Now you should be able to run the app and see the backgroundColor changed to purple:

The next step is to distribute the layout and divide the space equally between the sections.

Let's define the methods of our CollectionView.

The steps:

• Register a reusable cell with unique identifier
• Define the number of the items in the section
• Use the the registered cell

To use some of CollectionView methods we need to always conform to UICollectionViewDelegateFlowLayout as a superClass and to get the autoComplete of the methods. So let's start with registering the CollectionViewCell.

Inside View.DidLoad() we call the collectionView.register() method to register the reusable cell:

  collectionView.register(UICollectionViewCell.self, forCellWithReuseIdentifier: cellId)

Then we define the number of cells we will have inside the collectionView using numberOfItemsInSection. For now we just need to make it 5 items:

 override func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
        return 5
    }

The next step is to define the reusable cell using cellForItemAt that should return UICollectionViewCell and have a unique id called cellId. The code looks like this:

 override func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
        let cell = collectionView.dequeueReusableCell(withReuseIdentifier: cellId, for: indexPath)
        cell.backgroundColor = .red
        return cell
    }

The full code should look like this:

import UIKit

class ViewController: UICollectionViewController, UICollectionViewDelegateFlowLayout {
    let cellId : String = "cellId"

    override func viewDidLoad() {
        super.viewDidLoad()
        collectionView.backgroundColor = .purple
        collectionView.register(UICollectionViewCell.self, forCellWithReuseIdentifier: cellId)

    }


    override func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
        return 5
    }
    override func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
        let cell = collectionView.dequeueReusableCell(withReuseIdentifier: cellId, for: indexPath)
        cell.backgroundColor = .red
        return cell
    }

}

You should be able to see 5 items with red backgrounds on the screen:

Add a custom width and height to the cells

Now we need to place the cells in the correct order and give them a width and height. Each cell will take the width of the screen as width.

We are lucky to have sizeForItemAt method so we can give the cells a custom width and height. It's a method that should return a CGSize type:

 func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, sizeForItemAt indexPath: IndexPath) -> CGSize {
        let width = view.frame.width
        let height = CGFloat(200)

        return CGSize(width: width, height: height)
    }

So we made the Cell take the width of the screen by using view.frame.width and a custom height with is a CGFloat type.

Now you can see the result below in your Simulator :

Everything looks good so far. This time let's create a custom cell that can be reusable. Create a new Swift file named CustomCell:

CustomCell.swift should look like this below:

import UIKit

class CustomCell: UICollectionViewCell {
    override init(frame: CGRect) {
        super.init(frame: frame)

    }

    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
}

Now the next things we have to do is to modify two methods to support the reusable cell, collectionView.register and cellForItemAt. Let's first modify the register method. Replace UICollectionViewCell.**self** with CustomCell:

 collectionView.register(UICollectionViewCell.self, forCellWithReuseIdentifier: cellId)

Next we need to cast cellForItemAt to conform to CustomCell like below:

  let cell = collectionView.dequeueReusableCell(withReuseIdentifier: cellId, for: indexPath) as! CustomCell

If you run the app probably you won't notice any change, so give the CustomCell a backgroundColor backgroundColor = .yellow. Don't forget to remove the line cell.backgroundColor = .red in cellForItemAt. You should see the background color changed to yellow ?

Now it's time to put some salt into CutomCell :D

If you look at the Spotify home screen, each section which is a CustomCell in our example contains a section title, sub cells, and is horizontal:

Add a section title

Let's add a title label to the cell. Create the titleLabel element inside the CutomCell class:

let titleLabel: UILabel = {
        let lb  = UILabel()
        lb.text = "Section Title"
        lb.font = UIFont.boldSystemFont(ofSize: 14)
        lb.font = UIFont.boldSystemFont(ofSize: 14)

        return lb
    }()

Then add the element to the view inside init() block:

addSubview(titleLabel)

If you run the app you won't see any changes, and that's because we didn't put any constraint to the element yet. So let's add some constraints – add this property lb.translatesAutoresizingMaskIntoConstraints = **false** to titleLabel to be able to apply constraints to the element:

After we add titleLabel to the view, we define the constraints:

 addSubview(titleLabel)
titleLabel.topAnchor.constraint(equalTo: topAnchor, constant: 8).isActive = truetitleLabel.leftAnchor.constraint(equalTo: leftAnchor,constant: 8 ).isActive = true

Always make sure to add .isActive = true property – without it the constraint won't work!

Before we move on to the next part, let's first change the background color of the screen to black and also remove the yellow color for the cells:

Now comes the big part: putting sub cells into each cell. To achieve that we are going to add a CollectionView inside CustomCell.

To add a CollectionView inside UICollectionViewCell we need to add properties UICollectionViewDelegate, UICollectionViewDelegateFlowLayout, and UICollectionViewDataSource as superClass to CustomCell.

Let's create the collectionView element as any simple view:

    let collectionView : UICollectionView = {
        // init the layout
        let layout = UICollectionViewFlowLayout()
        // set the direction to be horizontal
        layout.scrollDirection = .horizontal

        // the instance of collectionView

        let cv = UICollectionView(frame: .zero, collectionViewLayout: layout)

        // Activate constaints

        cv.translatesAutoresizingMaskIntoConstraints = false

        return cv

    }()

Notice that we add layout to the collectionView as layer in the initializer as we did the first time with the viewController.swift. Here we also specify the direction of the FlowLayout to be .horizontal.

Let's add the collectionView element to the view as subView.

We gonna make a function that do that for us to make the code a little bit cleaner.

    fileprivate  func setupSubCells(){
        // add collectionView to the view
        addSubview(collectionView)

        collectionView.dataSource = self
        collectionView.delegate = self
        // setup constrainst
        // make it fit all the space of the CustomCell
        collectionView.topAnchor.constraint(equalTo: titleLabel.bottomAnchor).isActive = true
        collectionView.leftAnchor.constraint(equalTo: leftAnchor).isActive = true
        collectionView.bottomAnchor.constraint(equalTo: bottomAnchor).isActive = true
        collectionView.rightAnchor.constraint(equalTo: rightAnchor).isActive = true
    }

Make sure to set delegate to self for the collectionView and the dataSource as well:

collectionView.dataSource = self

collectionView.delegate = self

Then call the function within init block.

Xcode will display some errors if you trying to build the app because we are not conforming to UICollectionViewDelegate and UICollectionViewDelegateFlowLayout protocols. To fix that we need first to register the sub cell as a reusable cell.

Create a variable at the top of the class and give it a name of cellId so we can use it when we need the cell identifier:

let cellId : String = "subCellID"

collectionView.register(UICollectionViewCell.self, forCellWithReuseIdentifier: cellId)

Now we're missing two more methods to make the errors go away: numberOfItemsInSection that define the number of cells in the section and cellForItemAt that define the reusable cell. These methods are necessary for collectionView to work properly:

 // number of cells
func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
       return  4
    }

    // reusable Cell
     func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
        let cell = collectionView.dequeueReusableCell(withReuseIdentifier: cellId, for: indexPath)
         cell.backgroundColor = .yellow

        return cell
    }

The results should look like this:

As you can see, the collectionView are in purple as background and sub cells are yellow.

The last things we can do before ending this article is make subCells have the height of the section and as width. Again we are using sizeForItemAt to define the height and the width of the cell .

 func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, sizeForItemAt indexPath: IndexPath) -> CGSize {

        let width = frame.height
        let height = frame.height

        return CGSize(width: width, height: height)

    }

And here we are ?:

NICE! I'm gonna stop at this point so this post isn't too long. I'll make a second part where we are going to add some mocked pictures and fill it with some data.

Full source code ? here

Please please if you have any additions, questions, or corrections, post it in the comments below ? or hit me up on Twitter.

Subscribe to my email list to be notified when the second part of this tutorial is published

Apple launched the much-awaited iOS 13 updates globally on September 19 across all iPhones launched within the past 4 years (back to the iPhone 6s).

One of the biggest features of this update was the system-wide iOS 13 dark mode. It's expected to help with eye-strain caused by white light emitted by smartphone displays.

While this feature is a joy to end-consumers using Apple devices, it's a task for iOS developers to prepare an app ready for iOS 13 dark mode.

How to Set up your App for iOS 13 Dark Mode?

To help developers with this issue, here is useful info and steps showing how they can prep up an existing iOS app for iOS 13 dark mode.

• It’s not too hard to implement iOS 13 dark mode despite its system-wide scale.
• Enabling iOS 13 dark mode on your existing app is also simple mostly thanks to the latest iOS 13 SDK.

When using the latest version to build apps for iOS 13 dark mode, the OS will automatically update switches, buttons, and table views among other system controls. Though do note that images and text colors won’t adjust for dark mode automatically.

However, it’s still amazing to see that a system-wide change such as dark mode is so easy to implement. There are smaller code changes and more work that you'll be able to get done with the iOS 13 dark mode in that saved time.

How to Adapt Colors For iOS 13 Dark Mode

First, let’s start with changing system colors iOS 13 dark mode:

Now there are new system colors added in UIColor, one of which is a label color. Using these new colors helps support dark mode and other high contrast modes in iOS 13.

label.color = UIColor.secondaryLabel

Generally, you should use system colors for iOS 13 dark mode, which automatically adapts to changes in the interface for maintaining consistency across apps. However, developers can also choose to implement dark mode with custom colors.

The asset catalog colors introduced with iOS 11 make it much easier to support dark mode by adding dark versions of a custom set of colors.

You only have to select a preferred color from the catalog, then change Appearances to Any, Dark from the Attributes Inspector.

That's it! Now you have a custom iOS 13 dark mode ready for your mobile app.

Troubleshooting iOS 13 Dark Mode

Let's say your app is not following iOS 13 dark mode. What will you do? Here are some easy steps to solve this issue.

Step 1

You will need to know if the app is updated or not.

If the app is not working with iOS 13 Dark Mode or does not support it, simply update the app via Apple Store.

Step 2

Check whether the Dark Mode of your iOS app has been enabled or not.

If not, go to Settings - Display & Brightness - check whether "Dark" is enabled or not.

Step 3

If your app is fully updated, but isn't working with iOS 13 Dark Mode, then check the in-app settings. See the image:

If you want more help on setting up your iOS 13 Dark Mode, get it from the dedicated development teams. And, that is how I'm going to help you.

Also read tips for mobile app development on iOS. Hope all this information will be helpful for you.

Let's see what you have to do next.

Adapt Images For iOS 13 Dark Mode

Most images look great in iOS 13 dark mode, and at times they pop out in a way that really highlights details. However, you may still end up finding some images which look a bit off or unsuitable for dark mode.

The good news is that you can adjust images for dark mode in the same way text is adjusted.

All you need to do is select the image in the catalog and as done previously, and change attributes to Any, Dark in the Attributes Inspector. Now add the dark appearance of the image and we’re done.

Programmatically Detecting Changes in iOS 13 Dark Mode

Developers could face situations where they need to implement appearance changes in iOS 13 dark mode programmatically. This is how it's done:

override func traitCollectionDidChange(_ previousTraitCollection: UITraitCollection?) 
{
    super.traitCollectionDidChange(previousTraitCollection)

    let userInterfaceStyle = traitCollection.userInterfaceStyle // Either .unspecified, .light, or .dark
    // Update your user interface based on the appearance
}

Overriding traitCollectionDidChange helps in detecting appearance changes.

Then we only have to open traitCollection.userInterfaceStyle.

You can also verify if the existing appearance is using a new method you just implemented:

override func traitCollectionDidChange(_ previousTraitCollection: UITraitCollection?) {
    super.traitCollectionDidChange(previousTraitCollection)

    let hasUserInterfaceStyleChanged = previousTraitCollection.hasDifferentColorAppearance(comparedTo: traitCollection) // Bool
    // Update your user interface based on the appearance
}

Overriding the User Interface Style

Complete App

The system automatically opts-in any app linked against the iOS 13.0 or later SDK to both light and dark appearances.

If you need extra time to work on your app’s Dark Mode support or want to keep your app in a single style, you can opt-out by including the UIUserInterfaceStyle key (with a value of Light or Dark) in your app’s Info.plist file.

Setting this key causes the system to ignore the user’s preference and always apply the specific appearance to your app.

Note: Supporting iOS 13 Dark Mode is strongly encouraged. Use the UI UserInterfaceStyle key to opt-out only temporarily while you work on improvements to your app’s Dark Mode support.

Specific Screens

In iOS 13, you can now override the user interface style on specific views or view controllers. For example, you may want only a certain view controller to be in iOS 13 dark mode, while the rest of your app is in light mode.

To override the user interface style, just override this variable in the top view or view controller and it will propagate down to sub-views:

// Inside a UIViewController
override func viewDidLoad() 
{
    super.viewDidLoad()

    // Always adopt a dark interface style.    
    overrideUserInterfaceStyle = .dark
}

Closing Notes

Thanks for reading the article! Here we've explored how to set up an app for iOS 13 dark mode.

iOS 13 dark mode brings with it a unique stress-free way to use a smartphone. Perhaps we’ll see a future where dark mode replaces the default mode with the whiter backgrounds.

By following these coding guidelines and tips you can easily set up your app for dark mode on iOS 13.

If you need some expert help, feel free to get in touch with iOS developers for iOS 13 dark mode related queries.

Follow on Twitter for more updates: https://twitter.com/ValueCoders**

So it’s almost near about one month already since WWDC 2019 happened this year. All the developers are still busy what are new things Apple has added or updated for development. There were some big announcements and small announcements, but we, the developers need to make sure that we won’t miss anything important. So I am just creating a quick checklist of the items what we should not miss. Let’s make it short, concise and simple.

iOS:

1. iOS 13 will let you limit application location access to just once. Until now, there were three options — “Always”, “While Using” or “Never”. One more option has been added to this list “Just Once”. For the first time, you can share your location to an app — just once — and then require it to ask you again next time it wants.
2. Might be one of the popular announcements and people are going crazy about this. Yes, I am talking about “Apple Sign-in”. So it is a requirement from Apple that app developers must implement the company’s new single sign-in solution if the app already offers another third party sign in.
3. You can dismiss modal view controllers interactively which may break some of the existing applications. On iOS 13, by default, the user can just swipe the modal down to dismiss it. So when you are developing a new application make sure to take this into consideration. You can disable this behaviour by _isModalRepresentation = false_.
4. UISegmentedControl and UIStepper are different in iOS 13 with a whole new updated design.
5. A new update to Localization in iOS 13. From now, the user can set a different language to each of the application installed in your device. Developers have nothing to change or consider regarding the development, Settings application will take care on behalf of you.
6. iOS 13 has almost 1500 different system icons and UIImage got a new initializer UIImage(systemName: ) with this you can now initialize any of the system icons.
7. Until now when you download something in Safari that directly goes into downloads folder, but this year Safari got an update and you can change the default download folder to any other folder you want, even you can choose USB drive also.
8. Improvements to UIStoryboardSegue. Apple has introduced a new IBSegueAction modifier. Now you can pass additional context and parameters directly to the destination view controller that should be initialized.
9. Your apps can provide reservation information to Siri with context and at specific times so the user can take relevant actions based on the circumstances. For example, they can confirm a hotel reservation, be reminded to check in for a flight and get help returning a rental car.
10. With Core NFC framework, your apps can now support tag writing, including writing to NDEF formatted tags. The framework also provides support for reading and writing tags using native protocols such as ISO 7816, MIFARE, ISO 15693, and FeliCa.
11. Synch your Core Data store with CloudKit, giving users of your app seamless access to their data across all their devices. Core Data with CloudKit combines the benefits of local persistence with cloud backup and distribution.
12. Metal gives the GPU even greater control of the graphics and compute pipeline, adds features that make it easier to perform advanced GPU processing, and simplifies the work you need to do to support different kinds of GPUs. New tools, including Metal support in Simulator, help you get started faster and understand whether your iOS app is using Metal correctly.
13. With the new VisionKit framework, your app can let users scan documents using the device’s camera, like those you capture in the Notes app. Combine this feature with Vision’s text recognition to extract text from scanned documents.
14. Core ML 3 now supports on-device model personalization, allowing you to update a model by retraining or fine-tuning it with user-specific data privately from within your app. Core ML has also greatly expanded its support for dynamic neural networks with over 100 layer types.
15. The new PencilKit framework makes it easy to incorporate hand-drawn content into your app quickly and easily. PencilKit provides a drawing environment for your iOS app that takes input from Apple Pencil, or the user’s finger, and turns it into high-quality images you display in either iOS or macOS. The environment comes with tools for creating, erasing, and selecting lines.
16. MetricKit is a new framework that gives you on-device power and performance metrics about your app captured by the system, which you can use to improve the performance of your app.
17. The new Core Haptics framework that lets you compose and play haptic patterns to customize your app’s haptic feedback.
18. Use the new Apple CryptoKit framework to perform common cryptographic operations securely and efficiently, such as Computing and comparing cryptographically secure digests, Using public-key cryptography to create and evaluate digital signatures, Generating symmetric keys, and using them in other operations like message authentication and encryption.
19. Combine is a new framework that provides a declarative Swift API for processing values over time. These values can represent user interface events, network responses, scheduled events, and many other kinds of asynchronous data. With Combine, you declare publishers that expose values that can change and subscribers that receive those values from the publishers. Combine makes your code easier to read and maintain, by centralizing your event-processing code and eliminating troublesome techniques like nested closures and convention-based callbacks.
20. Keep your app content up-to-date and perform long-running tasks while your app is in the background using the new BackgroundTasks framework.
21. RealityKit is a new Swift framework to simulate and render 3D content for use in your augmented reality apps including the ability to add animation, physics, and spatial audio to your AR experience. RealityKit leverages information provided by ARKit to seamlessly integrate virtual objects into the real world.
22. Symbol images give you a consistent set of icons to use in your app, and ensure that those icons adapt to different sizes and to app-specific content. Symbol images use the SVG format to implement vector-based shapes that scale without losing their sharpness. They also support many traits typically associated with the text, such as weight and baseline alignment.
23. With iOS 13, the user can create and manage multiple instances of your app’s user interface simultaneously and switch between them using the app switcher. On iPad, the user can also display multiple instances of your app side by side. Each instance of your UI displays different content or displays content in a different way. For example, the Calendar app can display the appointments for a specific day and for an entire month side by side.
24. SwiftUI is a modern approach to building user interfaces for iOS, macOS, watchOS, and tvOS. You can build dynamic interfaces faster than ever before, using declarative, composition-based programming. The framework provides views, controls, and layout structures for declaring your app’s user interface. It also provides event handlers for delivering taps, gestures, and other types of input to your app, and tools to manage the flow of data from your app’s models down to the views and controls that users will see and interact with.
25. When the Voice Control Accessibility feature is turned on, there’s a blue microphone icon at the top of the device to indicate that the iOS device is in Voice Control mode. The dimmed icon when the phone doesn’t have your attention.
26. One of the new features in iOS 13 is an option in the Files app to connect to the server using SMB. This feature wasn’t working in the first beta but is functional in beta 2, so iOS 13 users can do things like connecting to a home NAS.
27. When sharing a webpage from the Safari Share Sheet, there are new options to share it as a PDF or a Web Archive. There’s also an “Automatic” option that picks the most suitable format for each app or action.
28. No more spam callers. iOS 13 now supports strictly silencing unknown callers.
29. In iOS 13, we got a new method on UIImageAsset named registerImage:withTraitCollection that can be used to create dynamic images for light and dark programmatically.
30. Running on Low Mobile data? A new “Low Data” mode has been added to avoid running out of data when you’re on a roaming plan.
31. When we do not have wifi then sometimes we face difficulty in downloading apps which are bigger in size. But after iOS 13, we can see a ray of light there. Now the limit has increased to 200 MB, still not enough? Then you can remove the restriction in Settings.
32. Share photo to others with original information in it. iOS 13 is giving you an option to add that original information when sharing.
33. Be happy to mute your iPhone. Apple has introduced a new completely redesigned mute indicator to match Apple pencil charging indicator.
34. Now you can initialize UIViewController subclasses with additional context and arguments (required for dependency injection).
35. If you are not a delegate fan then there are some good news for you. iOS 13 has updated some delegate based APIs to block based API.
36. You do not need to long press on any app and tap on the cross icon to delete. Now you can simply remove an app from AppStore update page by a left swipe.
37. Until now screenshot was taken only in image format. iOS 13 allows you to take a screenshot in pdf format also.
38. iOS 13 has a new _visualRecursiveDescription private API that can construct a visual representation of a view hierarchy. Very useful command for debugging in LLDB.
39. A new UICollectionViewCompositionalLayout class has been added to UIKit to make it easier to create compositional layouts without requiring a custom UICollectionViewLayout.
40. The UITableViewStyle enum gained a new public UITableViewStyleInsetGrouped case that can be used to create grouped style table views.
41. iOS apps using the File Management APIs can now be granted read/write access to an entire folder, rather than just a file.
42. Tired of swiping in scroll view? In iOS 13, you can drag the scroll indicator to go through a long document.
43. Apps intended for kids cannot include third-party advertising or analytics software and may not transmit data to third parties.
44. MDM provides access to sensitive data, MDM apps must request the mobile device management capability, and may only be offered by commercial enterprises, such as business organizations, educational institutions, or government agencies, and, in limited cases, companies utilizing MDM for parental controls. MDM apps may not sell, use, or disclose to third parties any data for any purpose, and must commit to this in their privacy policy. (referring to apps that abused MDM for Screen Time-like features).

Yeah, it’s quite a long list fully filled with new features. Developers can use all of them to make their application better and smoother. Now let’s take a look at the new frameworks that are coming with iOS 13-

Frameworks:

1. BackgroundTasks: Use the BackgroundTasks framework to keep your app content up to date and run tasks requiring minutes to complete while your app is in the background. Longer tasks can optionally require a powered device and network connectivity. Register launch handlers for tasks when the app launches and schedule them as required. The system will launch your app in the background and execute the tasks.
2. Combine: The Combine framework provides a declarative Swift API for processing values over time. These values can represent user interface events, network responses, scheduled events, and many other kinds of asynchronous data. Combine declares publishers to expose values that can change over time, and subscribers to receive those values from the publishers.
3. CoreAudioTypes: The CoreAudioTypes framework declares common data types and constants used by other Core Audio interfaces. This framework also includes a handful of convenience functions.
4. Core Haptics: Core Haptics lets you add customized haptic and audio feedback to your app. Use haptics to engage users physically, with tactile and audio feedback that gets attention and reinforces actions. Some system-provided interface elements — like pickers, switches, and sliders — automatically provide haptic feedback as users interact with them. With Core Haptics, you extend this functionality by composing and combining haptics beyond the default patterns.
5. QuickLookThumbnailing: You may want to create a miniature representation, or thumbnail, of a file and its contents to display within your app, or to provide a thumbnail to the operating system. For example, macOS shows thumbnails as part of the Finder app and its Quick Look feature. The QuickLookThumbnailing framework provides an API to generate thumbnails for common file types using the QLThumbnailGenerator object.
6. PencilKit: PencilKit makes it easy to incorporate hand-drawn content into your iOS or macOS apps quickly and easily. PencilKit provides a drawing environment for your iOS app that takes input from Apple Pencil, or the user’s finger, and turns it into high-quality images you display in either iOS or macOS. The environment comes with tools for creating, erasing, and selecting lines.
7. RealityKit: Use the RealityKit framework to implement high-performance 3D simulation and rendering. RealityKit leverages information provided by the ARKit framework to seamlessly integrate virtual objects into the real world.
8. VisionKit: VisionKit is a small framework that lets your app use the system’s document scanner. Present the document camera as a view controller, which covers the entire screen like the camera function in Notes.
9. SoundAnalysis: Use the SoundAnalysis framework to analyze audio and recognize it as a particular type, such as laughter or applause. The framework performs its analysis using a Core ML model trained by an MLSoundClassifier. Using the framework’s ability to analyze streamed or file-based audio lets you add intelligent audio recognition capabilities to your app.
10. CryptoKit: Use Apple CryptoKit to perform common cryptographic operations: Compute and compare cryptographically secure digests. Use public-key cryptography to create and evaluate digital signatures, and to perform the key exchange. In addition to working with keys stored in memory, you can also use private keys stored in and managed by the Secure Enclave. Generate symmetric keys, and use them in operations like message authentication and encryption. Prefer CryptoKit over lower-level interfaces. CryptoKit frees your app from managing raw pointers, and automatically handles tasks that make your app more secure, like overwriting sensitive data during memory deallocation.
11. Maps Web Snapshots: The Maps Web Snapshots service can be used to generate static map images from a URL. You can use Snapshots any time that an interactive map is not required, and in any place, you typically use an image URL — in web pages, and in places where JavaScript is not available, such as email clients.
12. DriverKit: Use DriverKit to create device drivers that the user installs on their Mac. Drivers built with DriverKit run in userspace, rather than as kernel extensions, for improved system security and stability.
13. MetricKit: With MetricKit, you can receive on-device app power and performance metrics captured by the system. A registered app receives reports containing data about the previous 24 hours at most once per day. Use the data in the reports to help improve the performance of your app.
14. SystemExtensions: Creating system extensions allow your app to enhance the capabilities of the user’s Mac, without the associated risks of developing kernel extensions (KEXTs). System extensions run in userspace, where they can’t compromise the security or stability of macOS. The system grants these extensions a high level of privilege, so they can perform the kinds of tasks previously reserved to KEXTs.
15. EndpointSecurity: Use the Endpoint Security library to create security-related software. Endpoint Security clients monitor system events for potentially malicious activity. Your client registers with Endpoint Security to authorize pending events, or receive notifications of events that have already occurred. These events include process executions, mounting file systems, forking processes, and raising signals.
16. USBSerialDriverKit: The USBSerialDriverKit framework provides an API for developing serial communication drivers for USB devices like modems and serial adapters. The framework builds on DriverKit by adding the ability to set attributes like baud rate and parity and work with a device’s universal asynchronous receiver/transmitter (UART).
17. USBDriverKit: Use the USBDriverKit framework to develop drivers for custom or non-class compliant USB devices for use with macOS. USBDriverKit provides C++ classes you can use to attach and configure your device and create USB message and stream pipes to exchange data. USBDriverKit devices work with the core types defined in the DriverKit framework.
18. HIDDriverKit: The HIDDriverKit framework provides C++ classes for developing drivers for human interface devices: keyboards, pointing devices, and digitizers like pens and touchpads. HIDDriverKit uses the core types defined in DriverKit, and adds features specific to human interface device development.

That’s all for today. Happy coding!!

???Thank you for reading???

All you need to know to build your autocompletion search bar with a UITableView and CoreData.

_Photo by [Unsplash](https://unsplash.com/@grohsfabian?utm_source=medium&utm_medium=referral" rel="noopener" target="_blank" title="">Fabian Grohs on <a href="https://unsplash.com?utm_source=medium&utm_medium=referral" rel="noopener" target="blank" title=")

In this article, I’m going to present how I built a custom search field with an autocompletion feature to retrieve data from CoreData. It’s a component that I needed in one of my apps and that can be very useful in many cases to improve the user’s experience.

We will see:

• How to set up a simple app with a search UITextField
• How to configure a TableView to show the search results
• How to make real-time queries to CoreData collections

1. Setting up the project

Just create a single view App with the following components (check CoreData at the project creation !). To be more concrete, let’s imagine this is for a travel recommendation App and the user needs to provide a city name to get all the information of the place.

UILabel : We will call it topLabel. We won’t need it.

UITextField: It’s the field that we will customize to have an autocomplete search field, so let’s call it searchTextField.

UIButton : It’s the button that will be pressed when the user will find the place that they want. Let’s call it searchButton.

The tableView will be added programmatically so that you will see how to set it up in any kind of situation.

To have a beautiful render, I added an UIImageView on the background with a wonderful beach image.

To connect all those components to our View Controller, select each of them and drag their reference using (Control (or Ctrl) ⌃ + Click) to your main View Controller swift file.

2. Configure our CustomSearchTextField class

To create our new class, we create a new file called CustomSearchTextField.swift. It’s in this class, that inherits from UITextField, that we will embed all the features that we need to implement our autocompletion search field.

Creating the TableView with the results:

To be able to show the completion results, we need to instantiate a UITableView that will display the most relevant results as below:

To do so we need to create a tableView object and then add it to the current view. In order to handle this new object, we need to override specific methods as shown below. All of the code needed to build the searchTableView will be handled by this method: buildSearchTableView().

Instantiating the tableView is as simple as creating a new UITableView object, but in order to access all of the functionalities of this new tableView object, we need to inherit from the TableViewDelegates and the TableViewDataSource methods. It is important to pay attention to two important variables:

• The tableView delegate: This variable will let us specify which object of the view needs to be informed when some changes occur in the tableView (in our case, this object is our SearchTextField which is in this context the self object)
• The tableView DataSource: This variable will let us specify how all the components of the tableView will be created and from which data. Here again, we need to set it to self.

Setting those two variables allows us to handle some actions related to the UITableView within our CustomSearchTextField class.

Now that the table view is created, we need to add data in it, and more concretely, this data will be stored into cells. We use methods inherited from the TableViewDataSource class to configure our cells and to add them to the tableView. In addition to this, the TableViewDelegates’ method will allow us to trigger where the user clicks and will print the content of the corresponding cell in the console.

But if you try to run the code above, nothing will happen because the tableView frame is not set and we didn’t bring the view to the front. In order to fix this, we now need to add a updateTableView() method:

Our TableView is set and is now supposed to work perfectly! But at this time we have to add data in our dataList if we want to display something. To do it simply for now, we will just add dummy data to our list: the text that the user enters in our search bar.

But the main goal of all of this is to give our users autocompletion results while they are typing in our search bar, so we need to observe when the user types a new letter and to update the tableView data according to that.

As you can see above, we modified the willMove() method in order to set how to handle each of the user interactions with the textField. The one that interests us is when the text field changes (when the user is typing). So each time that this action is activated, we add data to our list and we update our tableView.

Improving the user experience:

Even if our searchField doesn’t search at all, you must have seen that when we type and the results are starting to show up, all of the results are in plain text. This doesn’t look that much like an autocompletion search bar. To be more user-friendly, it would be nice to highlight the part of the text that we already typed in the text field and also to filter the results so that they correspond to what we are actually typing. Let’s do this ?

It’s time to create our filter method. This method will filter the relevant items from the dataList (the ones corresponding to what the user starts typing). We will use NSMutableAttributedString class to be able to highlight the part of the text that the user typed in the text field.

First, we create a SearchItem class that will represent each of our filtered results. As we are building our wonderful travel recommendation app, we will consider that those items are city names. Here is the SearchItem class:

We now need to change our global variable and to add a new one to store our filtered items:

Then let’s create our filter method:

By converting our string to an NSString, we can use the method range() that returns the range of the first occurrence of a given string within the string. By using this method we both know if the string corresponds to what the user is typing and the position of the corresponding string! That’s all we need to highlight this part of our item. We do this using setAttributes methods and we then add our item to the resultsList. Finally, we reload the data in our tableView.

Let’s create new test data to try our implementation:

Everything should work perfectly, we’re almost done! ?

3. Make queries to CoreData

It’s nice to have a beautiful search bar with a custom table view to display our autocompletion filtered results, but without data, it’s not very useful ?.

Let’s connect our search text field to CoreData storage.

Create a CoreData database:

In order to store our persistent data, we will create a new entity (table) in our database with two attributes (rows). To do so we click to the .xcdatamodeld file in the file explorer and create a new entity named Cities, add the two attributes that we need: cityName and countryName.

CustomSearchField..xcdatamodeld

Then we will modify the type of our dataList in CustomSearchField.swift to be a list of Cities instead of a list of SearchItems:

var dataList : [Cities] = [Cities]()

Make queries to the created database:

Now we need to create some methods to handle the saving and the fetching of new data in the database. To do so we need to create a context. The context is a specific zone where we will store all of our changing before committing them to the database. If you use git, this is like the staging zone. You first add your file to the staging area, and when you are ready with your changes you commit them to your git.

We change the beginning of our filter() method in order to query the data that corresponds to the user input instead of fetching all the data from the database:

The last thing to add is a new addData() method to populate our database. Be careful, this function needs to be called only one time as the data stored will become persistent, so comment the corresponding line in your code (just before the creation of the tableView in buildSearchTableView() ) after the first call! Even if the app is restarted, the data will still be available in the internal memory of the device.

That’s it ! We’re done ! ?

I started to dive into Swift programming a few weeks ago with an interesting MOOC that I found on Udemy. After I had acquired the basics of Swift and Xcode development, I began to work on my own projects with all of the useful documentation that I found on the web. This first tutorial is an opportunity for me to share all that knowledge that I acquired, so I hope that it has helped you!

If you have a question don’t hesitate to tell me in the comments! And don’t forget to give me a clap if you enjoyed the article ???

All the final project code is available here:

sinitame/customSearchField-medium
_Source code for Medium article : How to create an autocompletion UITextField using CoreData in Swift …_github.com

I love building tools with software, and that is why I am currently the Lead Developer for Green 13 Solutions.

Recently I have been having lots of fun using Swift and the Interface Builder in Xcode to create iOS apps.

I ran into some challenges when I was trying to create a scene where users can scroll to see content that overflows in the current content view. The content wasn’t scrolling properly and the text wasn’t automatically being shown properly for different screen sizes.

Here are some notes for my future self to refer to. I hope you find them useful as well!

Here is a repository for the project if you want to see the completed example.

What we will build

Our app will have a single page. The page will contain some text and users can scroll down to see the text that overflows from their current content view.

We will use the Interface Builder in Xcode to add a UIScrollView object, a nested UIView object and then a further nested UITextView object. We will use the Interface Builder to add constraints to these elements. The constraints will mean that Auto Layout can enable scrolling to happen properly and the Text View will automatically appear properly on different screen sizes.

A swift bit of background info (pun intended)

The UIScrollView object can be used as a parent object to other UIKit items such as UIView and UITextView.

Doing this means that all child objects can collectively have their origin shifted relative to the content view that is shown to the user. This means ‘scrolling’ behaviour works as users expect. Another benefit is that Auto Layout will properly size our elements on different screens as expected.

We use the terms ‘UIScrollView’ and ‘Scroll View’ interchangeably below, and similarly for View and Text View.

Below are the steps to follow.

Adding View

Create new project and selecting ‘Single View App’. If you click on Main.storyboard and you will see we have a scene with a blank View element.

Adding Scroll View

Drag a Scroll View UI element from the Object Library into the scene. Then add the constraints shown in the picture below to anchor the Scroll View element to the edges of its parent Safe Area.

Add a View element

Use the Object Library to drag a View element into the scene. The View will be the parent container for our Text View element.

Manually resize the View element with your cursor so that it fills the width of the screen.

Manually resized View element to fit into width

Anchor View to Scroll View

Click on the View element in the object hierarchy and drag+release your cursor onto the Scroll View element above it in the hierarchy. Click on the 4 topmost options to apply these constraints. Click on the ‘Equal Widths’ to apply this constraint also.

Why? Constraining the View this way means that a child Text View element we add works properly with Auto Layout. This happens because we constrain the Text View to the bottom of the View (which we anchored properly to the bottom of the Scroll View!) instead of directly to the bottom of the Scroll View.

You will see that the layout guides in the Interface Builder are red because there is some other error. We will fix this shortly.

Add these constraints to the View element

Add Text View as child to View

Add a Text View element inside the View element in the scene.

Add constraints to the Text View

Add the constraints in the picture below to the Text View.

Why? This will constrain the Text View relative to the View object that is surrounding it.

Adding constraints to Text View

Disable scroll behaviour in Text View

You should have a similar screen to the one below. You can see that there is still a lot of red in the Interface Builder.

You can remove these warnings by selecting the Text View element and deselecting the ‘Scrolling Enabled’ in the editor pane on the right hand side.

Deselect ‘Scrolling Enabled’ on the right to remove these red errors

Note that we will still have scroll behaviour with this approach but it will be the parent Scroll View that is actually being moved, not the individual Text View element. Its the same as how a leaf only moves on a river because the river that surrounds it is moving!

This is slightly subtle but quite important to understand as it underpins the whole solution.

Our approach means a Text View only scrolls because a Scroll View moves it — same as how a leaf only moves because the surrounding river moves it

Finally

Add some more content to the Text View. You should see that scrolling works as expected and that the Text View appears properly on different screen sizes.

This is the beauty of Auto Layout!

Screenshot of scrolled Text View using Xcode Simulator

Here is a repository for the project if you want to see the completed example.

All information about robins for the Text View content is directly from Wikipedia. Thanks to the community for this.

Why robins? Because I love birds and robins are particularly awesome creatures!

Thanks for reading, I hope you found this useful. Please let me know if you have any comments of questions!

I’m a Swift developer and indie maker. I have made several apps, and they’ve been featured on the App Store every time. Threader, a Twitter client that curates good threads and displays them on a single page, even became featured as App of the Day.

Here is some advice from my experience that might help Apple consider your app for promotion as well.

Note: Although this advice applies to all app categories, the game category is a bit more specific. I won’t cover the game app category in particular in this post.

How to get featured in the “New Apps We Love” section

Threader featured in “New Apps We Love”

A clean app

Of course, the first thing to consider is how to make a bug free app with a clean design. Think design, UX, and wording among other things. Don’t forget to test it (different devices, different OS, different people…).

Make things homogenous: use the same set of fonts and colors everywhere. Avoid text when you can. Don’t reinvent the wheel, especially if you’re not a designer. Use the standard iOS items: buttons, navigation bar, and so on.

It’s not always possible, but it can be useful to see people use your app. If you see that they’re not using it as expected or don’t manage to perform certain actions, then you might need to review your UX.

Use Apple’s APIs

Apple promotes their own products. They’ll be more inclined to feature an app that uses the latest Swift version and uses their own APIs. In 2017 they released ARKit and made a special category on the App Store to promote the apps using it.

Extensions

Although I don’t have solid proof of this, Apple likes when you take advantage of all their platforms. Think of iMessage, share & action extensions, and so on.

For example, Threader has an action extension. It allows you to open a thread directly from Twitter and read it on a single page, just like on the app. It’s an extension of the main app. It’s useful and allows certain actions outside of it, without opening it.

Threader’s action extension to read a thread directly from Twitter

Great visuals

All the information about your app is important and plays a role in getting featured. You can (re)read my previous article explaining how to submit an app. There’s some useful info in there (like the “Prepare for submission” and “App previews & screenshots” sections). The most important thing is your visuals. Make something clean, simple to understand, and with fewer words…

_Threader’s screenshots on the [App Store](https://itunes.apple.com/us/app/threader-for-twitter/id1317519091" rel="noopener" target="blank" title=")

Frequent updates

Apple likes frequent updates. Users like frequent updates. This doesn’t mean you need to create a new feature every day. But fix bugs, get feedback from your users, and push updates regularly.

Frequent updates are also recommended if you want to stay featured longer and stay on the top of the App Store. I push an update every two days or so when I’m featured. About once a week when I’m not.

iOS only

If your app is only available on iOS (meaning no Android version), I recommend you mention it. I suspect Apple likes exclusivity.

Ratings

Apple introduced a way to reply to users’ reviews on iTunes Connect. It’s useful to thank the good ones, but also to understand what went wrong for the bad ones and reply to those as well.

Reply to users’ reviews

Localizations

Translate your app into different languages. Especially if your app is available in several countries. Apple will appreciate that you took the time to do it.

It’s an annoying task, and localization is pretty hard to update. That’s why you should do it in the latest possible phase of your app development. I hope Apple will improve this one day, since it’s really painful.

Keywords & search results

ASO (App Store Optimization) is the process of improving the visibility of a mobile app […] in an app store. — [Wikipedia](wiki: https://en.wikipedia.org/wiki/App_store_optimization)

That’s why you need to choose your keywords carefully. I use App Annie sometimes to check the quality of my app’s keywords.

Finally, the most important step: Fill out the form

There’s actually a form to fill out to contact the App Store Editorial Team to get promoted.

Important to note: “please let us know 6–8 weeks in advance”. So think about it way before you submit your app. Especially for iOS where the market is way more crowded than the macOS market, for example.

_[Contact form](https://developer.apple.com/contact/app-store/promote/" rel="noopener" target="blank" title=") to fill out in advance

For me, the two most important fields in the form are:

• The “App Details / Describe your app” section
• Your Story

Globally, this is like sending your resume to Apple for an application. Sell your app and yourself (or your dev team).

The Holy Grail: How to be App of the Day

_[Threader featured as App of the Day](https://itunes.apple.com/us/story/id1367658799" rel="noopener" target="blank" title=")

If you get featured, then Apple might consider making your app the App of the Day or featuring it in the App/Game tab. If that’s the case, you’ll receive an email. You’ll have to produce several pieces of artwork/visuals and submit them via iTunes Connect.

A few pieces of advice from my one-time-being-App-of-the-Day experience:

• Be creative and look at the other Apps of the Day to give you an idea of what they look like.
• Carefully follow their guidelines for the artwork
• Respect the deadlines
• Consider releasing your app worldwide if that’s not already your plan. If you’re featured as App of the Day, you will get featured in all the countries where your app is available.

Promotional Artwork section on iTunes Connect

Just so you know, even if you submit your artwork, it doesn’t mean Apple is going to feature you. I know. You worked hard on this. And it might lead to nothing.

Also, after you’ve submitted your artwork, you probably won’t get any news from Apple about the status of your app. You just wait. And that’s it.

Let’s take my example: our apps have been considered two times for promotion. Both times we provided the artwork. Both times we waited for weeks. Both times we didn’t get any news. We didn’t get any replies to our emails. One app did not get featured. The other has been App of the Day. Without notice.

Additional general advice

_Photo by [Unsplash](https://unsplash.com/photos/82TpEld0_e4?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText" rel="noopener" target="_blank" title="">G. Crescoli on <a href="https://unsplash.com/?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText" rel="noopener" target="blank" title=")

The competition

Remember that the iOS App Store is very crowded. A lot of apps go out every single day. For example, I published IP Man (a Mac menu bar app to easily copy/paste your IP) to the Mac App Store. Even though I didn’t respect the deadline of ‘6–8 in advance’ (I know I didn’t respect my own guidelines), they featured it. And I can tell you it helps a lot with sales.

The Mac App Store is a good place to sell apps. There are way fewer apps available, so there is less competition. That’s likely why IP Man got featured.

_[IP Man](https://ipman.io/" rel="noopener" target="blank" title=") featured in “New Apps We Love” on the Mac App Store

Who are your competitors

Another piece of advice I can give you is to look at your competitors who have been featured, and other featured apps in general. I’m not saying all apps look the same, but there is definitely a pattern. Sell your app the Apple way. Use their vocabulary and their design style.

Note, though: You don’t have to say everywhere that your app is “insanely great”.

What you can do: on the App Store, go on the central bottom ‘Apps’ tab. Scroll until you find ‘Top Categories’ and click on ‘See All’. Now you see all the categories. Select the ones your app is in and navigate through the top apps: these are you competitors.

Check your competitors on the App Store

You can also check the Today tab and see the last week’s Apps of the Day. This gives you at least 6 examples.

The Today tab on the App Store

You don’t actually know if/when you’ll get featured

Apple doesn’t notify you. So like us, you’ll just notice a pickup of new users. You’ll check where they came from, not understanding what is happening. Then check the App Store to see if you are featured. And celebrate.

Useful links to become an App-Store-Feature Master

_Photo by [Unsplash](https://unsplash.com/photos/YLSwjSy7stw?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText" rel="noopener" target="_blank" title="">Alfons Morales on <a href="https://unsplash.com/search/photos/reading?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText" rel="noopener" target="blank" title=")

• Discovery on the All-New App Store, especially the last section “Getting featured”.
• I highly recommend you read Making the Most of Your Product Page. It explains how to fill out your app information and also gives you an overview of how it looks on the App Store. You even have more links for some of the sections.
• Show More with App Previews for those of you who use video previews.
• Optimizing for App Store Search, useful for choosing your keywords.
• Make the Most of the App Store, especially the first section “Build your App Store Presence”.
• The form to fill out to get promoted.

In general, follow Apple’s guidelines. I think it’s the most important. If you think of any other rules/tips, please let me know! I’ll add it with your name :)

I’m on Twitter if you want to see if my next apps will be featured or not. ??

Subscribe to my blog TwoMakers.io to receive updates about my journey.

Pretty Little Alerts..?

Notifications are a way to inform users when new data becomes available for their apps, even when the app is not running in the foreground.

For example, a messaging app might let the user know when a new message has arrived, and a calendar app might inform the user of an upcoming appointment.

With the release of iOS-10, Apple introduced brand new frameworks to support notifications, be it local or remote. This release was focused on customized notifications.

Without wasting any time, let’s just quickly jump in to the details.

Types of notifications

We can broadly classify notifications into two categories:

• Local notifications — the app configures the notification details locally and passes those details to the system. The system then handles the delivery of the notification when the app is not in the foreground.
• Remote notifications — you use one of your company’s servers to push data to user devices via the Apple Push Notification service (APNs).

Further down in the article, we’ll see how we can get ahold of both notification types. Let’s first start with an introduction to this new notification framework that we can use for our cause.

What’s new in iOS-10 for notifications?

With the release of iOS-10, Apple introduced two new frameworks to handle notifications:

• User Notifications Framework — manages both local and remote notifications.
• User Notifications UI Framework — customizes the appearance of the system’s notification interface.

We’ll be using these two frameworks and some platform-specific APIs to configure our notifications.

Along with the frameworks, the Notification service app extension was also introduced that allows you to modify the content of remote notifications before they are delivered.

Apple also allows customizing your notification’s UI though the Notification content extension.

Is it too much to remember? Yup...surely it is. But, don't worry. We’ll see everything step-by-step along with the relevant code. Just take it easy. ?

First things first — configure it!

Request Authorization

To get our app to notify the user of anything, we need to know whether the person using it actually wants that in the first place. Mayby they don’t like their phone ringing and displaying alerts all the time ? or maybe they actually want the updates, but not that irritating sound…naahhh!☠️

So, first of all we need to get permission from the user we’re going to notify. And that’s pretty simple — just two lines of code and we’re done:

You need to write that code in AppDelegate’s method — application:didFinishLaunchingWithOptions:before returning from it.

Please note: Because the system saves the user’s response, calls to [requestAuthorization(options:completionHandler:)](https://developer.apple.com/documentation/usernotifications/unusernotificationcenter/1649527-requestauthorization) method during subsequent launches do not prompt the user again.

Adding Categories and Actions — Actionable Notifications

The user notifications framework supports adding categories and actions to the notifications.

Categories — Define the types of notifications that the app supports and communicate to the system how we want a notification to be presented.

Actions — Each category can have up to four actions associated with it. Actions are basically custom buttons, that on tap dismiss the notification interface and forward the selected action to the app for immediate handling.

Okayyy! And what does that mean..??? Some code might help you understand better:

In the above code, we simply created a category named INVITATION with four different actions — remindLater, accept, decline, and comment.

The categories and actions are uniquely identified by their identifiers. Whenever a notification with a category is delivered, the system presents the notification along with all the actions associated with that category once the user expands it. This is what it will look like: ?

Define all the categories and actions just below where you configured notifications in application:didFinishLaunchingWithOptions: method.

Include the category identifier (eg. INVITATION) when scheduling your notification whether locally or remotely. We’ll see how to do that in the next section.

Scheduling local notifications

Now that we’re done with configuring our notifications, let’s see how to actually schedule one from within the app.

Scheduling a local notification requires just three simple steps:

1. Prepare the content
2. Add a trigger — when the notification should be fired
3. Schedule it for delivery

Let’s get on with the code quickly, so we don’t get confused with everything happening here. LOL ?

In the above code, along with the other content, we have also provided a categoryIdentifier to support actionable notifications. In case we don’t do that, the system will adopt it’s default behavior.

That’s it. That’s all that’s needed. And yes it definitely works...hehehe.? Give it a try before moving on any further. You can download the sample from here.

Please note: Apps behave differently in background and foreground states whenever a notification is delivered.

1. App not running / App in Background — the system displays local notifications directly to the user. We don’t get any callback in the app for that.
2. App in Foreground — the system gives the app the opportunity to handle the notification internally. The system silences notifications for foreground apps by default.

When the app is in foreground while the notification is delivered, we get the callback in [UNUserNotificationCenterDelegate](https://developer.apple.com/documentation/usernotifications/unusernotificationcenterdelegate)'s method — [userNotificationCenter(_:willPresent:withCompletionHandler:)](https://developer.apple.com/documentation/usernotifications/unusernotificationcenterdelegate/1649518-usernotificationcenter) where you can decide whether to handle the notification silently or alert the user about it.

Don’t forget to conform AppDelegate to UNUserNotificationCenterDelegate protocol and setting it as the delegate of [UNUserNotificationCenter](https://developer.apple.com/documentation/usernotifications/unusernotificationcenter) shared object in application:didFinishLaunchingWithOptions:.

let center = UNUserNotificationCenter.current()

center.delegate = self

We’re done with local notifications for now. Let’s move on to how we can schedule a notification from outside our app. Before that, let’s have a look at how to respond to the custom actions.

Responding to User Actions

Configuring notifications? ✔ Scheduling notifications? ✔

What about tapping a notification or any custom action in the notification? Where will it lead? In both the cases, the system notifies the app of the user’s choice.

Whenever the user performs any action in the notification, the response is sent to UNUserNotificationCenterDelegate's method — [userNotificationCenter(_:didReceive:withCompletionHandler:)](https://developer.apple.com/documentation/usernotifications/unusernotificationcenterdelegate/1649501-usernotificationcenter), where we can provide handling specific to each action.

Please note: if the app is not running when a response is received, the system launches the app in the background to process the response.

Remote notifications

Push notification or remote notifications, no matter what we call them, are one of the most frequently used with lots and lots of use-cases.

Be it social media or calendar or any of the utilities apps, we can see them almost everywhere. From news apps notifying us of the latest content, to Medium itself alerting us of the latest published articles.

Ever wonder how do they even do that? Local Notifications ?? It could be…it does the same thing — right? Maybe we can do some more configuration in the local one itself and get that working?

But Medium, for example, don’t have access to the app on our personal device, so how could it schedule any notifications? Exactly! It can’t. This is something different and something more than just the local ones.

Ok, how about we send the notification from some point and show it at some other point — will this answer our question? Yup, it surely will. But how to do that? Remote Notifications it is.

This is exactly what they do. This is the feature that has solved THE BIG PROBLEM of “Keeping up-to-date”.

Terminology

• APNs — the centerpiece of the remote notifications feature. It is a cloud service that allows approved third-party apps installed on Apple devices to send push notifications from a remote server to users over a secure connection.
• Device Token — An app-specific token that is globally unique and identifies one app-device combination. It enables communication between the Provider, APNs, and the Device.
• Provider — Server that actually sends the remote notification including the device token and other information to APNs.

Important note: Never cache device tokens in your app. Instead, get them from the system when you need them.

APNs issues a new device token to your app when certain events happen. The device token is guaranteed to be different, for example, when a user restores a device from a backup, when the user installs your app on a new device, and when the user reinstalls the operating system.

When you attempt to fetch a device token but it has not changed, the fetch method returns quickly.

Please note: The ability of APNs to deliver remote notifications to a non-running app requires the app to have been launched at least once.

How it actually works

Below is a small and quick explanation of how all the above technologies work together in sync to complete the remote notifications workflow.

1. App registers with APNs
2. APNs sends device token to Device with then sends it to App
3. App sends this device token to Provider
4. Provider sends notifications with that device token to APNs which then sends it to Device which then sends it to the App.

If a notification for your app arrives with the device powered on but with the app not running, the system can still display the notification. If the device is powered off when APNs sends a notification, APNs holds on to the notification and tries again later.

Handle it in the app

Now that we are aware of what remote notifications are and what things are needed to make them work, let’s now move on to how we can make our app support them. Because nothing happens on its own ?. We need to make some configurations for them to work.

To be able to handle remote notifications, our app must:

1. Enable remote notifications in capabilities — just one-click and you are done with this step. In the Capabilities tab of our Xcode project, enable the Push Notifications option. Ensure that Push Notifications is added to the App ID that we are using for the project.

2. Register with Apple Push Notification service (APNs) and receive an app-specific device token

Requesting to register with APNs is quick and easy. Just add the below code in UIApplicationDelegate’s method— application:didFinishLaunchingWithOptions: before returning from it.

UIApplication.shared.registerForRemoteNotifications()

Now there are two possibilities: either we get registered successfully or the process fails.

On successful registration, APNs sends an app-specific device token to the device inUIApplicationDelegate’s method— [application:didRegisterForRemoteNotificationsWithDeviceToken:](https://developer.apple.com/documentation/uikit/uiapplicationdelegate/1622958-application?language=objc).

In case of faliure, we receive a callback in UIApplicationDelegate’s method—[application:didFailToRegisterForRemoteNotificationsWithError:](https://developer.apple.com/documentation/uikit/uiapplicationdelegate/1622962-application?language=objc).

3. Send the device token to notification provider server

As of now, we’ve received the device token from APNs. Now, we need to send this token to our provider, which will use it while pushing any notifications to our device.

Since we don’t have a provider, for now we can use Easy APNs Provider for testing our push notifications. Further down, we’ll see how exactly we can make use of this tool.

For now, just download and install it on your Mac.

4. Implement support for handling incoming remote notifications

We have our device token, and our provider also knows about it. Next, the Provider will send the notification including this token and other information in it, and we’ll get it on our device.

Now what? What will happen when it arrives? How will it appear on the device? What will happen when we tap on it? What about all the actions that we configured earlier? Can we get them here?

Too many question ❓❓❓Well, don’t worry. We’ll have answers to all of them one-by-one.

What will happen when it arrives? We’ll get a callback in UIApplicationDelegate’s method— [application(_:didReceiveRemoteNotification:fetchCompletionHandler:)](https://developer.apple.com/documentation/uikit/uiapplicationdelegate/1623013-application). It tells the app that a remote notification has arrived that indicates there is data to be fetched.

How will it appear on the device? It will appear with the default notification interface. If the notification’s payload is configured with category, it will appear as the actionable notification with all the actions attached to that category. We’ll discuss the payload in next section.

What will happen when we tap on it? Same as local notifications. UNUserNotificationCenterDelegate's method — [userNotificationCenter(_:didReceive:withCompletionHandler:)](https://developer.apple.com/documentation/usernotifications/unusernotificationcenterdelegate/1649501-usernotificationcenter) is called with the response object.

Handle it on the Provider

We have covered most of the things we need to integrate push notifications into our app. Although we know how to handle them in the app, we are still short of handling them on the provider.

We have the provider. It knows what device token to use, but that alone won’t pop up a notification on our device with some title and other details. Neither will it make any of the actions appear.

So, pushing notifications from the provider requires the following items:

1. A device token
2. APNs certificate — we can obtain it from the developer account
3. Payload — any custom data that you want to send to your app, and includes information about how the system should notify the user. It’s simply a JSON dictionary with some key value pairs. The below illustration might help you understand it better.

Let’s see what’s all in that JSON dictionary:

1. aps dictionary — the most important one. Contains Apple-defined keys and is used to determine how the system that is receiving the notification should alert the user.
2. alert dictionary — it is more of a self-explanatory item. Provides the content of the notification.
3. category — for actionable notifications. All the actions attached to that category will be available in the notifications.
4. content-available — To support a background update notification, set this key to 1.
5. mutable-content — To enable a notification’s modification through Notification Service App Extension, set it to 1.

Here you can read more about customizing the payload as per your requirements. This is a reference to the keys that we can add in the aps dictionary

Notification Service App Extension

At this point, we know what remote notifications are, how they work, what all we need to get them working — pretty much everything! Since we just got them working perfectly✌️.

Now the question is, what if we want to modify some content in the notification received from the provider, before presenting it on the device? What if the notification contains some image link that we need to download before delivering it to the user? Can we do that with what we already know? We don’t have access to the provider…so how will we?

We can’t actually. We can’t change what we get, but we can definitely change what we present.

That’s what Notification Service App Extension is all about— modifying the content of remote notifications before delivery. It is as simple as it looks. No fancy code, nothing. It’s really very simple.

Adding Notification Service Extension to the project

Extensions in an xcode project are added as a target. Select File — New — Target — Notification Service Extension.

Prerequisites

Before we begin to modify the content, there are some restrictions on when the content is allowed to be modified.

Content can be modified only if:

• The remote notification is configured to display an alert.
• The remote notification’s aps dictionary includes the mutable-content key with the value set to 1.

We cannot modify silent notifications or those that only play a sound or badge the app’s icon.

So, to support any modifications in the notifications’ content, these conditions must be fulfilled.

Modifying the content

The default notification service extension target provided by Xcode contains a subclass of the [UNNotificationServiceExtension](https://developer.apple.com/documentation/usernotifications/unnotificationserviceextension) class for us to modify.

It contains two methods:

1. [didReceive(_:withContentHandler:)](https://developer.apple.com/documentation/usernotifications/unnotificationserviceextension/1648229-didreceive) — make any needed changes to the notification and notify the system when you’re done. This method has a limited amount of time (about 30 secs) to perform its task and execute the provided completion block.
2. [serviceExtensionTimeWillExpire()](https://developer.apple.com/documentation/usernotifications/unnotificationserviceextension/1648227-serviceextensiontimewillexpire) — Tells us that the extension is about to be terminated. Give us one last chance to submit our changes. If we don’t update the notification content before time expires, the system displays the original content.

Let’s look at an example. We’ll change the body in payload in Code Snippet 7 to “Address: Sea Shells Apartments, Mumbai”.

All the default implementation of both the methods is provided by the extension itself. We just have to make the changes we want, like in Line 8 in the above code snippet. Just a single line of code for now. Similarly, you can modify other fields as per your requirements.

Notification Content Extension

Having an eye-catching UI is always better than a simple default UI. Adding some colors and some pretty fonts is never a bad idea. We’re going to do the same with our notifications to make them look Wow!?

And and and…Apple is here to our rescue again. Notification content extension it is. This presents a custom interface for a delivered local or remote notification.

Adding Notification Content Extension to the project

I think we already know how to do that. Don’t we? We’re going to the same what we did for adding Notification Service Extension. Select File — New — Target — Notification Content Extension.

Adding some keys to extension’s Info.plist

To support custom UI for local and remote notifications, we need to make some changes in the Info.plist file of content extension.

1. UNNotificationExtensionCategory (reqd.) — A string or an array of strings. Each string contains the identifier of a category declared by the app. Category, I must say, is really really important for notifications. Custom UI will only appear for the notifications lying in the specified categories.
2. UNNotificationExtensionInitialContentSizeRatio (reqd.) — A floating-point number that represents the initial size of the view controller’s view expressed as a ratio of its height to its width. It’s the view controller that we’ll use for making custom UI. We’ll discuss that in the upcoming section.
3. UNNotificationExtensionDefaultContentHidden — if true: show only custom content. If false: show custom+default content.
4. UNNotificationExtensionOverridesDefaultTitle —if true: set the notification’s title to the title of the view controller. If false: notification’s title is set to app’s name.

Here is an illustration that can help us understand the above keys better.

In the above illustration, the keys in Info.plist are configured as:

1. UNNotificationExtensionCategory — INVITATION
2. UNNotificationExtensionInitialContentSizeRatio — 1
3. UNNotificationExtensionDefaultContentHidden — false
4. UNNotificationExtensionOverridesDefaultTitle — false

Creating the custom UI

Notification content extension provides us with a UIViewController that conforms to [UNNotificationContentExtension](https://developer.apple.com/documentation/usernotificationsui/unnotificationcontentextension) protocol. This controller presents the interface of the notification. The Storyboard file in the extension contains a single ViewController that we can use to create whatever UI we want the notification to present.

Once we create the UI, we need to connect the elements in the NotificationViewController in order to fill in the details. Whenever a notification arrives with an expected category, we receive a callback in UNNotificationContentExtension’s method — [didReceive(_:)](https://developer.apple.com/documentation/usernotificationsui/unnotificationcontentextension/1648525-didreceive) . This is the place where we can add details to our customized UI.

We’re almost done with our notification’s custom UI. Just 1 more thing. Since the custom UI is attached to the notifications’ category, that may have some actions attached to it. And…you got that right! ?We’ll get our actions automatically without any custom handling. Brilliant!?

Content + Beautiful UI + Custom Actions — Everything done. What more can we ask for? Apple, you are great!?

One last point: we can add handling to the custom actions in the extension, too. The system calls [didReceive(_:completionHandler:)](https://developer.apple.com/documentation/usernotificationsui/unnotificationcontentextension/1845197-didreceive) method to respond to any selected actions. If our view controller doesn’t implement that method, the system delivers the selected action to your app for handling.

If implemented, we need to handle all the possible actions in this method. One thing that is important here is the completion closure.

completion: The block to execute when you are finished performing the action. You must call this block at some point during your implementation. The block has no return value.

The closure accepts a single parameter dismiss of type [UNNotificationContentExtensionResponseOption](https://developer.apple.com/documentation/usernotificationsui/unnotificationcontentextensionresponseoption) . We provide the following options:

1. doNotDismiss — Don’t dismiss the notification interface.
2. dismiss — Dismiss the notification interface.
3. dismissAndForwardAction--Dismiss the notification interface and forward the notification to the app.

That sums up our notifications. Too much to remember? Practise makes Progress ?. Try making your own notifications now!

Sample Project

You can download the sample project from here.

And the sample project for Notification Content Extension can be found here.

Further reading

Don’t forget to read my other articles:

1. Everything about Codable in Swift 4
2. Color it with GRADIENTS — iOS
3. Coding for iOS 11: How to drag & drop into collections & tables
4. All you need to know about Today Extensions (Widget) in iOS 10
5. UICollectionViewCell selection made easy..!!

Feel free to leave comments in case you have any questions.

Back in 2014, Apple made it possible to add an app preview to the the App Store. App previews are the best way to show potential users what your app has to offer before they download the app. In fact, users are 3x more likely to install an app with an app preview, according to StoreMaven.

Unfortunately, many solo makers don’t have the budget to hire a professional to make an app preview. Recently, I found myself in this position, and after some digging, I found a couple of free tools to make a quality app preview.

In this post, I’m going to go over the following:

1. Preparing the content
2. Recording the video
3. Editing the video
4. Common issues

I’m assuming that you are using a Mac, which comes with Xcode, Quicktime, and iMovie for free. If you are not using a Mac you might need to purchase these tools.

Preparing the content

Each app developer knows the most engaging and fun parts of their app. Make sure to highlight those in your app preview. Figure out where you need to add text overlays and ensure the text contrasts with the background it’s displayed on.

As of iOS 11, you can have up to three app previews to show off your app. It may be tempting to use the entire 90 seconds you are given, but I would suggest loading your most interesting features in the first one. If users aren’t interested in your app by the first preview, it’s unlikely they’ll take the time to watch the other two.

Finally, you may want to show the users how they will interact with your app. To show off touches and gestures, use GSTouchesShowingWindow. It’s super easy to install and will show off how users will interact with your app.

Recording the video

Once you have decided the content you want to show, you can start recording your video. The easiest way to do this is to use Quicktime to record the screen of a connected iPhone.

Plugin your iPhone, then open quicktime and hit File > New Movie Recording. This will open a recording window. From the dropdown next to the record button, you can select the device you have connected.

Using a connected device means that you are limited only to the devices you have. Luckily, you can use Xcode CLI to record your simulator actions.

To record with the Xcode CLI, begin running your simulator in Xcode. Then, open your terminal and enter the following command:

$ xcrun simctl io booted recordVideo example.mp4

Perform the actions you want to record in the simulator then ctr-C in your terminal to end the recording session. The above command will add the video example.mp4 to the current directory of your terminal.

Editing the Video

There are two goals you are trying to hit while editing your preview:

1. Show your app in the best light possible
2. Edit the preview down to between 15 and 30 seconds

The best tool for editing an app preview is iMovie. Open iMovie and click File > New App Preview. Drop your video into the media area to add it to your project.

I’m not going to go into details of how to edit an iMovie app, but the UI is pretty intuitive. Just drag and drop the scenes you want onto the lower area to add them to your clip. command+B will allow you to split your clip so you can fit cool transitions and keep track of the pacing better. You can add transitions between split clips, audio, and title screens.

You can add text overlays and audio to your app preview in iMovie before exporting it

Once you are done editing, click File > Share > App Preview (if you don’t see App Preview you can also click file). Then, select the destination you want to save it to and hit enter. After a few seconds, your video will be available.

Common issues

So at this point there is a good chance you already have everything ready to go, but when you try to upload your preview to iTunes Connect, you get an error. It is likely that your problems are caused by one of these two app preview requirements:

1. Your app preview’s resolution must match the requirements for the device type
2. Your app preview must run at 30 fps

The likelihood that your app preview’s resolution doesn’t meet the requirements is pretty low, but I actually ran into trouble even when I recorded directly from my iPhone. For whatever reason, Quicktime captured everything off by one pixel, so iTunes Connect refused to let me upload the video.

After some searching, I found a free tool that lets you crop your .mov (or any video type) into the correct resolution. Go to ezgif.com and click Video to GIF on the nav bar. This opens another nav bar below the first one, where you will see Crop video. Click that, then you can upload your quicktime .mov file. Crop the video to the size you need and download the new file.

If you face issues related to your app preview not running at 30 fps, that’s an easy one to fix (for free) with ffmpeg. Open your terminal, ensure you have homebrew installed, and enter:

$ brew install ffmpeg

Now with ffmpeg installed, cd into the directory that contains your video and enter:

$ ffmpeg -i "original.mov" -r 30 "converted_30fps_video.mov"

This will output your video converted to 30 fps.

Conclusion

You should now have an app preview that meets all of Apple’s requirements. Having an app preview is important so that your app stands out from the millions of apps on the app store. I found that the tools used in this guide landed me with a high quality app preview that I felt marketed my app well, and it didn’t cost a dime!

I hope this guide saved you some time and money. Good luck on the app store!

Thanks so much for reading! If you liked this story, follow me on Twitter where I post articles about product management, engineering, and design.

Many iOS apps use Google Maps. This is a very common feature, so I have decided to prepare an ultimate guide on the Google Maps SDK for iOS. This tutorial covers everything that you might need to know.

I hope that my readers will request features, so I can expand this article. Everything will be documented in this post! ?

Installation

Before we start coding, we must install the Google Maps iOS SDK first. You might prefer some other dependency manager, but I would recommend CocoaPods.

Create a Podfile inside your project root directory, and copy the following code:

source 'https://github.com/CocoaPods/Specs.git'target 'YOUR_TARGET_NAME' do  pod 'GoogleMaps'end

All you need to do is changing the YOUR_TARGET_NAME string with a real value. Save the file and close it. Open the terminal and cd to the root directory of the project, then type pod install. You're done! ?

Get an API key

To use the Google Maps iOS SDK, you will need an API Key. To generate the key you will need to visit the Google API Console.
Create a project, and navigate to ‘Credentials’.

Then, click ‘Generate Credentials’ and pick API Key. You will need to provide your projects bundle id. The key is generated by the unique bundle id, so if it’s changed, the Google Maps services won’t work!

Go to your project, and in your AppDelegate.swift class add import GoogleMaps. Then, copy the following code to application(_:didFinishLaunchingWithOptions:)

GMSServices.provideAPIKey("YOUR_API_KEY")

Step 1 — Add a map

I will start by showing you how to set up the map together with a basic marker. The code that you will see here is tested in parallel as I write.

Let’s start! ?

Visit your UIViewController (where you need to add the map). Create a custom UIView with the size you need. Assign the GMSMapView class as a Custom Class to the UIView (see the screenshot below). Also, don't forget to connect the delegate.

Finally, some code!

Let’s get back to the UIViewController and write some code. ⌨️
️In the below snippet, I have added the whole class so you can get a better picture of what is going on.

GMSCameraPosition tells the map which coordinates to take as a center point. To show a simple marker on the map, use the showMarker() function.

At the end of the file, add an extension which will “store” the GMSMapViewDelegate methods that we need.

Step 2 — Delegate methods

I will now introduce you to some GMSMapViewDelegate methods and their powers. ✊

GMSMarker InfoWindow

In Google Maps, an InfoWindow is a popup window with extra information about a given location. It is displayed when the user taps on the marker we added above.

Our InfoWindow is customizable. You can attach your own UIView with whatever components you need.

I have written an example implementation. This assumes in most cases people will use a custom InfoWindow,

• didTapInfoWindowOf() detects when the user taps on the InfoWindow.
• markerInfoWindow() adds the custom UIView that we want to show to the marker.
• didLongPressInfoWindowOf() detects when the InfoWindow has been long pressed.

Drag GMSMarker

Another interesting feature in GMSMapViewDelegate is the ability to drag the marker. This can be achieved with a minimal amount of code.

All you have to do is turn on the “switch”, by calling marker.isDragabble=trueon the marker created above.

In order to drag the marker, you will need to use a long press. If you need to be notified when the user starts and ends dragging, you can implement these three delegate methods:

• didBeginDragging notifies once — when the dragging has started.
• didDrag notifies while the marker is being dragged.
• didEndDragging notifies once — when the dragging has ended.

GMSMarker position

What if you need to change the GMSMarker position while the user is tapping on the map? Well, GMSMapViewDelegate offers a solution for that as well. A single delegate method can intercept the coordinates (latitude and longitude) of the tapped area. It will then assign their values to the marker.

• didTapAt() returns the coordinate from the tapped area on the map

Step 3 — Adding shapes

The Google Maps iOS SDK makes it simple to draw a shape. I will cover how to draw with polylines, polygons and circles.

Polylines

Shapes can be built using lines. We can draw lines in Google Maps using ‘polylines’. The object that will help us with the drawing is called GMSPolyline.

To create a polyline, you will need to create a path using GMSMutablePath. It needs two or more points to start creating a path.

If you have used the above example, you will get a rectangular shape like the one shown.

Some other useful tips:

• To remove a polyline from the map, call mapView.clear().
• You can change the color of the line by using polyline.strokeColor=.black.
• Change the width of the line by calling polyline.strokeWidth=3.

Polygon

Polygon is almost the same as polylines. It works using the same approach, with a few minor differences.

For example, GMSPolygonwill draw a shape. You can then use fillColor to fill in the drawn area. Here is an example of what this looks like.

Radius (circle)

The final shape we will look at is a circle. This is probably the easiest shape of all, since it’s always the same!

To achieve this, we need to use theGMSCircle class. Here, we are not passing a path. Instead, we use one coordinate to specify the circle’s center. We also define a radius (measured in meters).

TheGMSCircle class contains the same properties as the polygon, includingfillColor , strokeColor and strokeWidth.

Step 4 — Properties and Settings

This part will cover a few properties and settings that are often used when using Google Maps in your app. Let’s take a look at them.

Change marker icon

The GMSMarkercontains two different properties for changing the marker icon.

• marker.icon=UIImage(named: "image.png") in this approach, you pass an image filename. This replaces the default one.
• marker.iconView=customView You can also add a custom view instead of an image. This can be used for more complex markers. For example, you may want to add some animation, or multiple components (instead of a single image). Note the icon property gets overwritten when iconView is called.

Add ‘My Location’ button

The ‘My Location’ button appears in the bottom right corner. Clicking the button will animate the map to show the user’s current location.

To add this, set mapView.settings.myLocationButton = true. The button will appear.

Zoom controls

Google Maps SDK for iOS doesn’t provide inbuilt zoom controls (but the Android SDK does). You will need to write your own logic instead.

All you need to do is add two buttons with ‘+’ and ‘-’ icons. When tapped, these will call mapView.animate(toZoom: zoom).

Control gestures

You can turn on or off any gesture that you can see on the map. For example, you might want to disable zooming, or turn off scrolling.

There are a total of four gestures available to you:

mapView.settings.scrollGestures = falsemapView.settings.zoomGestures   = falsemapView.settings.tiltGestures   = falsemapView.settings.rotateGestures = false

I hope that you have enjoyed this tutorial. If you want to read more on Google Maps SDK for iOS, write me a comment. I would be very happy to expand this tutorial with your requests.

That’s it from this tutorial and if it helped you please ? or share this story so others like you can find it. Thank you for your attention! ?

Check out my latest project:

‎1x2 BET - Soccer Tips & Odds
_‎HOT ODDS Each day, we generate a list of the hottest odds in the world. These are odds that have dropped the most…_apple.co

Read more of my writing on Medium:

Introducing Clean Swift Architecture (VIP)
_Forget MVC, now!_hackernoon.comYour ultimate guide to the Google Maps SDK on iOS, using Swift 4
_Many iOS apps use Google Maps. This is a very common feature, so I have decided to prepare an ultimate guide on the…_medium.freecodecamp.orgSWIFT — Custom UIView with XIB file
_Custom UIView with XIB file is a very common practice in iOS Development. Custom UIView classes don’t contain XIB files…_medium.comHow to add Spotlight support to your iOS app
_A Swift tutorial that will make your app available in Spotlight search_hackernoon.comCore Data Relationships
_Understanding One-to-One and One-To-Many relationships_hackernoon.comUnderstanding Auto Layout in Xcode 9
_All you need to know about Auto Layout_hackernoon.com

Subscribe to my Newsletter: