Jayesh Kawli's Swift, iOS and Random things blog

Pull to Refresh Control and One Time Data Fetch Task in SwiftUI

iOS 15 introduced two new APIs to simplify data load and refresh actions. These APIs will allow users to trigger the data refresh on request and allow one-time data load execution on the very first run - For example, when the view has been loaded in the memory for the

Async

SwiftUI - Using AsyncImage API in iOS15

Apple introduced an AsyncImage API in iOS15. This API solves the long-standing image download problem for iOS developers without using any third-party image downloading libraries. Asynchronously downloading remote images from URL has been a long pain point and having to add third-party frameworks only adds to this pain. Let's see

low data mode

Low Data Mode on iOS 13

Apple introduced a low data mode feature in iOS 13. Using this mode, (On iOS 13), users can specify their preference to minimize the data usage when the network is really bad or they want to save on their data while being on the cellular. When the low data mode

Asynchronous

AsyncSequence in Swift

Apple introduced the AsyncSequence in Swift 5.5. This is one of the major features released in this Swift version to improve the Swift concurrency. In today's post, we are going to take a look at what AsyncSequence are and how you can make your own custom async sequence in

Combine

Building a Network Service in Swift Using the Combine Framework

Hello readers! Welcome to another blog post. Today we are going to see how to build a generic network service using Apple's Combine framework. Making network calls from the app is the bread and butter of any standard iOS application. Today, we will see how to build a network service

Advanced SwiftUI

Using Custom Environment Key-Values in SwiftUI with Examples

SwiftUI offers flexibility in many different ways. One of the ways it does this is, its ability to create a custom environment key-value pair. These are nothing but a collection of environmental values propagated through a view hierarchy. When you don't want to pass down values through a multiple view

navigation

Cheatsheet for SwiftUI Navigation

How navigation works in SwiftUI often proves to be confusing for new folks. In spite of the apparent attempt by Apple engineers to make app development easier for developers, navigation is one area that is confusing, counterintuitive, and difficult to handle in SwiftUI. In this blog post, I am going

Radial Gradient

How to Use Gradients in SwiftUI - Radial Gradients

💡This is the second post in the series of Gradients in SwiftUI. If you want to learn about linear gradients in SwiftUI, please follow Linear Gradients in SwiftUI link to know more about itApple defines general gradient as, A color gradient represented as an array of color stops, each having

gradient

How to Use Gradients in SwiftUI - Linear Gradients

💡This is the first post in the series of Gradients in SwiftUI. If you want to learn about radial gradients in SwiftUI, please follow Radial Gradients in SwiftUI link to know more about itApple defines general gradient as A color gradient represented as an array of color stops, each having

The Correct Way to Dismiss Screen in SwiftUI

In today's blog post, I am going to talk about the most commonly used API to dismiss presented or pushed view controllers on the screen in SwiftUI. However, when I say "talk", I am going to write about how that approach may not be suitable everywhere, what's the Gotcha behind

custom alignment

Custom Alignments in SwiftUI

SwiftUI offers a novel way to lay out views in iOS apps. Unlike an explicit constraint system where you clearly specify how you want to layout views with respect to each other's leading, trailing, or center edges, SwiftUI offers a more subtle way to arrange views instead of going into

SwiftUI

Extending SwiftUI views beyond the safe area

iOS offers a safe area at the top and bottom of the screen. This safe area prevents content from touching notches present and helps developers place their views within the visible portion of the overall interface. However, there are cases when we want to extend beyond this safe area. For

Creating a Preview Layer in the iOS app Using Gradient Overlay

SwiftUI gradient has many applications in a real app. One such application is preview overlay. Websites and apps often show us partial content as a preview before we can either subscribe or pay to view the full content. In this post, we will see how to create a preview layer

shadow

Adding a 3D Horizontal Shadow Effect in iOS apps using SwiftUI Gradient

SwiftUI gradient has many applications to add a delightful experience in your iOS applications. One such example is adding a horizontal shadow view which acts as a boundary between different sections on iOS. LinearGradient can be used to create the appearance of a horizontal shadow to achieve this purpose. The

SwiftUI

Adding Shadows to SwiftUI views

Among many things, SwiftUI provides an easy way to add shadows to view with a few lines of code. In today's post, we will see how to add a background shadow to any view in any direction in SwiftUI. To add a background shadow, we will use the background API

code snippet

Creating and Reusing the Code Snippet in Xcode

Developers often run into situations where they need to use a similar snippet of code again and again. It's a lot of effort trying to find it in the codebase, from a random blog or the StackOverflow. Xcode offers a way to save any code snippet and later retrieve it

small PRs

Limiting the Pull Requests Size

Code review is a great medium to get quality code in the repository and to your customer. One of the mechanisms that facilitate code reviews is a pull request. They together make sure the code is well checked and free from any bugs. Despite the benefits of pull requests, one

async-await

async Alternatives and Continuations - Bridging legacy async code with async-await structure (Advanced Swift Topic)

If you haven't yet read couple of my posts that introduce a new async-await construct in Swift, below are the links you can follow to know more about itHow to use async/await in Swift using ExamplesUsing async/await APIs in Swift 5.5. Examples of using async await and

contrast

Make Your App Visually Accessible - Analyze and Improve the Image Contrast Using Xcode Tool

Whenever you release an iOS app, you want to make sure everyone using the app should have a pleasant experience using it. It includes content, colors, text, and animations. In this article, we will focus on how you can make your app visually accessible by improving the contrast of images

Petrol Pump

Improving the Petrol Pump / Gas Station Operation and Making it More Efficient

Why This Post?Last month, when I was in India, I visited a petrol pump near my house. The petrol pumps or as anyone in the USA might say "Gas Stations" in India are different than the ones in the USA. In the USA, most of the gas stations are

low level debugging

Low-level Debugging on iOS using lldb

WWDC16 Session 417 offered a lot of insight into low-level iOS app debugging applicable for both Objective-C and Swift codebase. In this blog post, we will go over some of the improvements offered by new lldb features and see how you can use them for your own personal or work-related

Async

Running async network operations in parallel on iOS using async-await

Running parallel network operations on iOS was not always a smooth process. I remember that at my previous jobs, developers opted to use either third-party libraries or DispatchGroup to trigger parallel requests. These solutions had their own pros and cons. Using DispatchGroup in the code was tedious and its block-based

Unit Tests

Use Test Repetitions Mode in Xcode to Diagnose and Fix Flaky Tests

If you've written unit tests in the past, there is a fairly good chance that you came across the flaky tests. Flaky tests are the ones whose success or failure is unreliable. They might pass today and may fail for some time before reverting back to pass status. They add

unit test

Xcode 13 Introduces a New Way for Handling Expected Unit Test Failures

In my previous blog post, I wrote about using a couple of ways to either suppress or skip expected test failures. In Xcode 12.5, Apple introduced a new API XCTExpectFailure to provide a better way to handle expected (And hopefully temporary and fixable in near-future) test failures. In todays'

XCTest

Handling Expected Unit Test Failures in Swift and Xcode

Xcode allows developers to make unit testing efficient and free from noise by skipping certain tests with known failure. There are many cases where engineers want unit tests to effectively catch failing code. But how about those where they know tests will fail, but still want to keep those tests

Fresh Beginning