<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Er Rahul Rajkumar Gupta on Medium]]></title>
        <description><![CDATA[Stories by Er Rahul Rajkumar Gupta on Medium]]></description>
        <link>https://medium.com/@errahulrajkumargupta?source=rss-9d1ffe5d6a45------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*FX12CQ2nEPs4PCws.</url>
            <title>Stories by Er Rahul Rajkumar Gupta on Medium</title>
            <link>https://medium.com/@errahulrajkumargupta?source=rss-9d1ffe5d6a45------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 12:15:34 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@errahulrajkumargupta/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Mastering iOS Memory Security: Hardware-Enforced Isolation for High-Stakes Apps]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-snippet">Why Memory Matters Beyond APIs</p><p class="medium-feed-link"><a href="https://medium.com/@errahulrajkumargupta/mastering-ios-memory-security-hardware-enforced-isolation-for-high-stakes-apps-d05a7190ae79?source=rss-9d1ffe5d6a45------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@errahulrajkumargupta/mastering-ios-memory-security-hardware-enforced-isolation-for-high-stakes-apps-d05a7190ae79?source=rss-9d1ffe5d6a45------2</link>
            <guid isPermaLink="false">https://medium.com/p/d05a7190ae79</guid>
            <category><![CDATA[blockchain-security]]></category>
            <category><![CDATA[web3-security]]></category>
            <category><![CDATA[ios-app-security]]></category>
            <category><![CDATA[mobile-security]]></category>
            <category><![CDATA[swift]]></category>
            <dc:creator><![CDATA[Er Rahul Rajkumar Gupta]]></dc:creator>
            <pubDate>Sun, 11 Jan 2026 18:53:28 GMT</pubDate>
            <atom:updated>2026-01-11T18:53:28.602Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Mastering Dependency Injection in iOS with Swinject]]></title>
            <link>https://medium.com/@errahulrajkumargupta/mastering-dependency-injection-in-ios-with-swingject-1223d104e905?source=rss-9d1ffe5d6a45------2</link>
            <guid isPermaLink="false">https://medium.com/p/1223d104e905</guid>
            <category><![CDATA[mvvm-ios]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[mvvm-architecture]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[dependency-injection]]></category>
            <dc:creator><![CDATA[Er Rahul Rajkumar Gupta]]></dc:creator>
            <pubDate>Mon, 13 May 2024 09:05:01 GMT</pubDate>
            <atom:updated>2024-05-13T09:07:28.423Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Introduction:</strong> Dependency injection (DI) is a powerful design pattern used in software development to decouple classes and improve code maintainability, testability, and scalability. In iOS development, dependency injection plays a crucial role in building modular and flexible applications. While there are several DI frameworks available for iOS, Swinject stands out as a lightweight and intuitive solution for managing dependencies in Swift projects. In this article, we’ll explore the fundamentals of dependency injection and how Swinject simplifies the process of injecting dependencies into your iOS app.</p><p><strong>Understanding Dependency Injection:</strong> Dependency injection is a design pattern where the dependencies of a class are provided from the outside rather than created internally. This approach allows for greater flexibility and modularity in your codebase, making it easier to replace or mock dependencies during testing and reducing coupling between components.</p><p>There are three common types of dependency injection:</p><ol><li><strong>Constructor Injection:</strong> Dependencies are passed into a class through its constructor.</li><li><strong>Property Injection:</strong> Dependencies are set as properties of a class after initialisation.</li><li><strong>Method Injection:</strong> Dependencies are passed into methods of a class as parameters.</li></ol><p>Swinject leverages constructor injection as the primary method for injecting dependencies into Swift classes.</p><p><strong>Getting Started with Swinject:</strong> Swinject is a lightweight dependency injection framework for Swift that offers a simple and intuitive API for managing dependencies in your iOS projects. To get started with Swinject, follow these steps:</p><ol><li>Install Swinject via Swift Package Manager (SPM) or CocoaPods.</li><li>Define your dependencies using protocols.</li><li>Register your dependencies with the Swinject container.</li><li>Inject dependencies into your classes using property wrappers.</li></ol><p>Let’s walk through each of these steps in more detail.</p><p><strong>Overview:</strong> Here, I am using dependency injection with MVVM architectural pattern where APIService protocol which is responsible to fetch the data is injected to the View Models and View Models will be injected to View.</p><p><strong>Defining Dependencies:</strong> In Swinject, dependencies are defined using protocols. This allows you to define the contract that each dependency must adhere to, making your code more modular and testable. For example:</p><pre>protocol APIService {<br>    func fetchPosts(page: Int, completion: @escaping (Result&lt;[Post], NetworkError&gt;) -&gt; Void)<br>    func fetchComments(id: Int?, completion: @escaping (Result&lt;[Comment], NetworkError&gt;) -&gt; Void)<br>}</pre><p>This code is a simple protocol which have two function to fetch the posts and comments regarding to a post respectively.</p><p>Below class is the actual implementation of the above protocol:</p><pre>class DefaultAPIService: APIService {<br>    private let networkManager: NetworkManager<br><br>    init(networkManager: NetworkManager = .shared) {<br>        self.networkManager = networkManager<br>    }<br><br>    func fetchPosts(page: Int, completion: @escaping (Result&lt;[Post], NetworkError&gt;) -&gt; Void) {<br>        var urlComponents = URLComponents(string: RequestURLs.posts)<br>        let requestModel = PaginationRequestModel(page: page, limit: 10)<br>        urlComponents?.queryItems = requestModel.queryParams.map { URLQueryItem(name: $0.key, value: $0.value) }<br>        self.networkManager.fetchData(url: urlComponents?.url, completion: completion)<br>    }<br>    <br>    func fetchComments(id: Int?, completion: @escaping (Result&lt;[Comment], NetworkError&gt;) -&gt; Void) {<br>        let url = URL(string: RequestURLs.comments.replacingOccurrences(of: &quot;{postId}&quot;, with: &quot;\(id ?? .zero)&quot;))<br>        self.networkManager.fetchData(url: url, completion: completion)<br>    }<br>}</pre><p><strong>Registering Dependencies: </strong>Once you’ve defined your dependencies, you can register them with the Swinject container using the Container class. For example:</p><p>To implement this, I created a class which is a singleton class. The role of this class is to create the object of the class and inject to the other class which is dependent on it.</p><pre>class DependencyInjector {<br>    static let shared = DependencyInjector()<br>    let container = Container()<br>    <br>    private init() {<br>        container.register(APIService.self) { _ in DefaultAPIService() }<br>        container.register(PostViewModel.self) { resolver in<br>            let apiService = resolver.resolve(APIService.self)!<br>            return PostViewModel(apiService: apiService)<br>        }<br>        container.register(CommentViewModel.self) { resolver in<br>            let apiService = resolver.resolve(APIService.self)!<br>            return CommentViewModel(apiService: apiService)<br>        }<br>    }<br>}</pre><p><strong>Explanation:</strong></p><p>This code defines a <strong>`DependencyInjector`</strong> class responsible for managing dependencies using a container-based approach. Let’s break down each component of the code:</p><p><strong>1. `static let shared = DependencyInjector()`:</strong> This line creates a singleton instance of the `<em>DependencyInjector</em>` class, ensuring that there is only one instance of the injector throughout the application.</p><p><strong>2. `let container = Container()`:</strong> The `<em>container</em>` property represents a dependency injection container, which holds mappings between protocols (or types) and their concrete implementations. It allows resolving dependencies at runtime.</p><p><strong>3. `private init() { … }`:</strong> The private initialiser ensures that the `<em>DependencyInjector</em>` class cannot be instantiated directly from outside the class. Instead, the singleton instance is accessed via the `<em>shared</em>` property.</p><p>4. Inside the initializer, we register dependencies with the container using the `<em>register</em>` method. Each registration associates a protocol (e.g., `<em>APIService</em>`, `<em>PostViewModel</em>`, `<em>CommentViewModel</em>`) with a closure that creates an instance of the corresponding concrete type.</p><p><strong>- `container.register(APIService.self) { _ in DefaultAPIService() }`:</strong> Registers `<em>APIService</em>` protocol with a closure that instantiates a `<em>DefaultAPIService</em>` object.<br> <br> <strong>— `container.register(PostViewModel.self) { resolver in … }`: </strong>Registers `<em>PostViewModel</em>` protocol with a closure that creates an instance of `<em>PostViewModel</em>`. The closure receives a `<em>resolver</em>` parameter, which allows resolving other dependencies (in this case, `<em>APIService</em>`) from the container.<br> <br> <strong>— `container.register(CommentViewModel.self) { resolver in … }`:</strong> Similar to `<em>PostViewModel</em>`, this line registers `<em>CommentViewModel</em>` protocol with a closure that creates an instance of `<em>CommentViewModel</em>`. It also resolves `<em>APIService</em>` dependency from the container.</p><p>Overall, this code sets up a central `<em>DependencyInjector</em>` responsible for managing dependencies and provides a mechanism for resolving dependencies throughout the application. It follows the dependency injection principle, allowing for easier testing, modularity, and flexibility in the codebase.</p><p><strong>How resolver works:</strong></p><p>The `<em>resolver</em>` parameter passed to the closure inside the `<em>register</em>` method provides a mechanism for resolving other dependencies from the container within the closure itself. Here’s a more detailed description:</p><p><strong>1. Purpose:</strong> The `<em>resolver</em>` parameter allows the closure to request and resolve dependencies from the container as needed during the registration process.</p><p><strong>2. Usage:</strong> Within the closure, developers can access the `<em>resolver</em>` object to request dependencies by their corresponding types (protocols). The `<em>resolver</em>` then retrieves and provides instances of the requested dependencies from the container.</p><p><strong>3. Flexibility:</strong> By using the `<em>resolver</em>` parameter, developers can implement more complex dependency setups where dependencies of a registered type also need to be resolved and injected. This enables more flexible and dynamic dependency management within the application.</p><p><strong>4. Example:</strong> In the provided code snippet, the closures for registering `<em>PostViewModel</em>` and `<em>CommentViewModel</em>` both use the `<em>resolver</em>` to resolve the `<em>APIService</em>` dependency. This demonstrates how dependencies can be resolved and injected into other dependencies during registration.</p><p>In summary, the `resolver` parameter enhances the flexibility and power of the dependency injection mechanism by enabling dynamic resolution of dependencies within the registration closures. It facilitates the construction of dependency graphs and promotes modularity and testability in the application architecture.</p><p><strong>Injecting ViewModel to View:</strong></p><p>Here, in MVVM, we are considering ViewController as View. We can inject the ViewModel to View in following way:</p><pre>class PostViewController: UIViewController {<br><br>    private var viewModel: PostViewModel?<br>    <br>    override func viewDidLoad() {<br>        viewModel = DependencyInjector.shared.container.resolve(PostViewModel.self)<br>        viewModel?.loadNextPage()<br>    }<br>}</pre><p>However, we are using singleton instance of DependencyInjector directly in our ViewController but by this way, our view controller is not creating any object.</p><p><strong>Summary:</strong></p><p>We can summarise the this article in following flow diagram:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BaDrojl8Ob1uhMvKp3lSNw.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1223d104e905" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Bluetooth Low Energy Basics]]></title>
            <link>https://medium.com/@errahulrajkumargupta/bluetooth-low-energy-basics-f185846c5659?source=rss-9d1ffe5d6a45------2</link>
            <guid isPermaLink="false">https://medium.com/p/f185846c5659</guid>
            <category><![CDATA[blé]]></category>
            <category><![CDATA[bluetooth-low-energy]]></category>
            <category><![CDATA[ble]]></category>
            <dc:creator><![CDATA[Er Rahul Rajkumar Gupta]]></dc:creator>
            <pubDate>Fri, 26 Aug 2022 09:36:19 GMT</pubDate>
            <atom:updated>2022-08-26T09:36:19.267Z</atom:updated>
            <content:encoded><![CDATA[<p>Hello everyone,</p><p>So today, I am going to discuss about the concepts of BLE (Bluetooth Low Energy) technology.</p><p>So In this article, you will learn about:</p><ol><li>What is BLE?</li><li>Types of Devices</li><li>How many modes in BLE communication?</li></ol><p><strong>What is BLE:</strong> Actually, BLE is the enhanced version of old bluetooth technology. So, if anyone is thinking that BLE is only technology for bluetooth so that is not correct. I will discuss about this myth in this article.</p><p>BLE is an advance technology where we can transform the data by consuming very low amount of power of the devices. Because, here sender or receiver devices are not waiting for the data while they are in connection, meanwhile they can sleep.</p><p>They will be active only during the data transmission is going on.</p><p>Now, this can not be happen in the old Bluetooth version since there we can transfer the huge amount of data also. But in BLE, only small chunk of data transfer is allowed.</p><p>Although, if we implements BLE smartly so we can transfer whole file as well but that is not the topic of this article.</p><p><strong>Types of Devices: </strong>As in case of client/server architecture, server is a device where the data is stored and client is another device which want to access those data.</p><p>Similarly, Since here peripheral has the data so we can say peripheral is server and since central wants to access of these data so we can consider it as client. C for Central and C for Client.</p><p><strong>Example: </strong>Suppose there are two devices: One is MI Band and another is your mobile.</p><p>So, here this MI band may have some of your health related data like what is your pulse rate, how many steps you walked today, what is your blood pressure etc.</p><p>Now, suppose that you are working to develop a mobile app where you need to read this data. So in this case since, your mobile wants to access data so it will be central and since Mi band is source of information that you want to read, so it will be peripheral.</p><p><strong>Mode of BLE communication:</strong></p><ol><li><em>Advertising mode:</em> We can say advertising mode is simply a mode where the peripheral broadcasts its data to multiple central at a same time and central can read only that data. It cant write the data into peripheral device.</li><li><em>Connection mode: </em>In this mode, the communication between one peripheral and one central only where central can perform read and write both operation on peripheral data.</li></ol><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FU2xOU51OcWw%3Fstart%3D61%26feature%3Doembed%26start%3D61&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DU2xOU51OcWw&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FU2xOU51OcWw%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/bfb990f04c1183b89f4ff7a27da3e598/href">https://medium.com/media/bfb990f04c1183b89f4ff7a27da3e598/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f185846c5659" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Transferring file over Bluetooth Low Energy in iOS]]></title>
            <link>https://medium.com/@errahulrajkumargupta/transferring-file-over-bluetooth-low-energy-in-ios-1f5222c384b9?source=rss-9d1ffe5d6a45------2</link>
            <guid isPermaLink="false">https://medium.com/p/1f5222c384b9</guid>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[ios-app-development]]></category>
            <category><![CDATA[ble]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[bluetooth-low-energy]]></category>
            <dc:creator><![CDATA[Er Rahul Rajkumar Gupta]]></dc:creator>
            <pubDate>Thu, 23 Aug 2018 08:25:45 GMT</pubDate>
            <atom:updated>2018-08-23T09:09:14.419Z</atom:updated>
            <content:encoded><![CDATA[<p>This time is era of wireless technology, in which bluetooth communication is playing vital role. In mobile technology, where hardware resources are very limited, so their optimized utilization is very important part in app development. Thats why Apple provided CoreBluetooth framework for Bluetooth Low Energy technology by which the device can transfer the data with very low energy consumption of the device. Originally, it is developed to transfer low amount of data from one machine to another but we can transfer the huge size of file also.</p><p>Before explain how, I want to let you know something:</p><ol><li>Here, I will use Swift 4.0 for code.</li><li>I will abbreviate the term ‘Bluetooth Low Energy’ as BLE in this post.</li><li>I am using BLE 4.0.</li><li>For this post, you should have basic knowledge of BLE implementation in iOS. So if you are not familiar with BLE part of CoreBluetooth, Please read it before start.</li></ol><p>In this implementation, I tried to utilize full throughput limit of the BLE GATT protocol and after some hit and trial, I was able to transfer maximum 180 bytes of data at a time. So, here I will use 180 bytes as maximum throughput size.</p><p>To do this, we have to follow some steps:</p><p><strong>Step 1: Convert file content into Data:</strong></p><p>Before start sending we must have the content as Data because CoreBuetooth class is sending data in form Data object. So, we have to convert the content into Data. This content may be converted into Data like this:</p><blockquote>if let filepath = Bundle.main.path(forResource: “example”, ofType: “txt”) {<br> do {<br> let contents = try Data(contentsOf: filepath, options: .mappedIfSafe)<br> <br> } catch {<br> // contents could not be loaded<br> }<br> }</blockquote><p><strong>Step 2: Data extraction and chunk creation</strong></p><p>Now, the next step is to extract the part of file data to create a chunk of size of throughput(Here it is 180 bytes). One thing we have to keep in mind that if our remaining content data size if greater than throughput, we will extract the data of throughput size otherwise we will consider the whole remaining data as single payload for the chunk.</p><p>Please refer code below:</p><blockquote>func extract() -&gt; Data? {</blockquote><blockquote>guard content!.count &gt; 0 else {</blockquote><blockquote>return nil</blockquote><blockquote>}</blockquote><blockquote>var range:Range&lt;Data.Index&gt;</blockquote><blockquote>// Create a range based on the length of data to return</blockquote><blockquote>if (content?.count)! &gt;= 180{</blockquote><blockquote>range = Range(0..&lt;180)</blockquote><blockquote>}</blockquote><blockquote>else{</blockquote><blockquote>range = Range(0..&lt;(content?.count)!)</blockquote><blockquote>}</blockquote><blockquote>// Get a new copy of data</blockquote><blockquote>let subData = content?.subdata(in: range)</blockquote><blockquote>// Mutate data</blockquote><blockquote>content?.removeSubrange(range)</blockquote><blockquote>// Return the new copy of data</blockquote><blockquote>return subData</blockquote><blockquote>}</blockquote><p><strong>Step 3: Sending data from Central to Peripheral</strong></p><p>In normal case central is behaving like client while peripheral as server. In this case our client i.e. central will send the data to server (peripheral) and wait for acknowledgement. To send the data, each time you have to call the method extract() to get the extracted data and send it like this:</p><blockquote>func sendData() {</blockquote><blockquote>sentDataPacket = extract()</blockquote><blockquote>if sentDataPacket != nil {</blockquote><blockquote>peripheralDevice?.writeValue(sentDataPacket!, for: characteristic!, type: .withoutResponse)</blockquote><blockquote>}</blockquote><blockquote>else{</blockquote><blockquote><strong>peripheralDevice?.writeValue(kEndFileFlag.data(using: String.Encoding.utf8)!, for: characteristic!, type: .withoutResponse)</strong></blockquote><blockquote>}</blockquote><blockquote>}</blockquote><p>Here, <em>kEndFileFlag</em> is String value of “EOF” flag denoting ending of the file. When peripheral device receive <em>kEndFileFlag</em> flag, it consider that now the file data transfer has been completed so now it can proceed next operation on received data.</p><p>After sending a single chunk, the center has to wait for the acknowledgement from peripheral side. Here, peripheral will return the same data packet as acknowledgement.</p><p>To do this, peripheral will notify me when his characteristic value will be update. For this, I have implemented the setting like this:</p><blockquote>peripheral.setNotifyValue(true, for: characteristic)</blockquote><p>So, when the value of the characteristic will be update, peripheral will to central by calling this method of the delegate:</p><blockquote>func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?)</blockquote><p>So, each time when you send the data chunk to peripheral on a characteristic, you will get the acknowledgement by this method. When you receive the acknowledgement, then its good time to send next chunk. So the methos implementation should be like this:</p><blockquote>func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {</blockquote><blockquote>guard error == nil else {</blockquote><blockquote>delegate?.handleError(errorMessage: (error?.localizedDescription)!)</blockquote><blockquote>return</blockquote><blockquote>}</blockquote><blockquote>if (characteristic.uuid.uuidString.lowercased() == characteristicUUID) {</blockquote><blockquote>//data receive</blockquote><blockquote>if(characteristic.value != nil) {</blockquote><blockquote>if characteristic.value == kEndFileFlag.data(using: .utf8){</blockquote><blockquote>// It means file transfer has been completed so now you can perform whatever next task you want</blockquote><blockquote>}</blockquote><blockquote>else{</blockquote><blockquote>sendData()</blockquote><blockquote>}</blockquote><blockquote>}</blockquote><blockquote>}</blockquote><p><strong>Step 4: Receiving data on peripheral side</strong></p><p>Each time, when peripheral receive data chunk from central, following delegate method will be execute:</p><blockquote>func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?)</blockquote><p>So, we can handle the received data in implementation on this method like this:</p><blockquote>func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {</blockquote><blockquote>// if there was an error then print it and bail out</blockquote><blockquote>if error != nil {</blockquote><blockquote>print(“Error updating value for characteristic: \(characteristic) — \(String(describing: error?.localizedDescription))”)</blockquote><blockquote>return</blockquote><blockquote>}</blockquote><blockquote>// make sure we have a characteristic value</blockquote><blockquote>guard let value = characteristic.value else {</blockquote><blockquote>return</blockquote><blockquote>}</blockquote><blockquote>// make sure we have a characteristic value</blockquote><blockquote>guard let nextChunk = String(data: value, encoding: String.Encoding.utf8) else {</blockquote><blockquote>print(“Next chunk of data is nil.”)</blockquote><blockquote>return</blockquote><blockquote>}</blockquote><blockquote>// If we get the EOF flag, we can handle the data as we want</blockquote><blockquote>if (nextChunk == kEndFileFlag) {</blockquote><blockquote>// Handle the data as you want</blockquote><blockquote>} else {</blockquote><blockquote>dataBuffer.append(value)</blockquote><blockquote>print(“Next chunk received: \(nextChunk)”)</blockquote><blockquote>}</blockquote><blockquote>}</blockquote><p>Here, dataBuffer is mutable Data.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1f5222c384b9" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>