DEV Community: Ben

2 hours to master RxSwift - Part 1

Ben — Tue, 14 Mar 2023 02:23:28 +0000

About this series

This series is to help people to get started with RxSwift easily with straight forward examples, plain explanation. And YES, if you would like to spend 2 hours with a bit efforts, I am quite confident you will master the RxSwift from zero to hero.

This is the part 1 of this series which will cover most of the topic on RxSwift, from the basic concept and usage to some advanced techniques. The whole series is using RxSwift 6.5.0 (latest as for now) and Swift 5.0.

Roadmaps:

Part 1: Introduction and Quick example

Part 2: Core concepts

Part 3: Observable in depth

Part 4: Subscriber in depth

Part 5: Scheduler

Part 6: Common Operators

Part 7: RXSwift with MVVM

Introduce RxSwift

RxSwift is a popular reactive programming framework for Swift, which allows us to write code that responds to changes and events.

Before dive into the RxSwift, let's have a basic under standing on what is the Reactive programming. Reactive programming is a programming paradigm which can efficiently handle asynchronous data streams, by using a set of operators to transform and manipulate these streams, such as user's input, UI change, network responses and so on.

Why need RxSwift

Compared with the existing programing paradigm - Functional programming, there are few benefits.

RxSwift enhances code reusability and reduces the amount of code.
RxSwift makes it easier to understand business logic, abstract asynchronous programming, and unify code style, therefore make the code more readable and easier to maintain.
RxSwift makes it easier to write integrated unit tests, increasing code stability.

We will use a short example on above characters.

Quick example of using RxSwift

1, Integrate RxSwift framework into project

Like many other 3rd party libraries, we need to install the framework. There are a couple of ways of doing so as fully documented on its github page: https://github.com/ReactiveX/RxSwift. Notice that the current latest version is RxSwift 6.5.0. However, there is an issue with the Swift Package Manager (SPM) installation. So we can either follow their workaround or use other means.

2, Functional programming way

Imagine we are doing a view which will verify user's input on their email address. Here is what we used to do:



//
// ViewController.swift
// RXSwiftExercise
//
// Created by Ben Liu on 6/3/2023.
//

import UIKit

class ViewController: UIViewController {

  @IBOutlet weak var emailTextField: UITextField!
  @IBOutlet weak var emailErrorInfo: UILabel!

  override func viewDidLoad() {
    super.viewDidLoad()
    // Do any additional setup after loading the view.
    emailTextField.addTarget(self, action: #selector(textFieldDidChange(_:)), for: .editingChanged)

  }

  @objc func textFieldDidChange(_ textField: UITextField) {
    guard let email = textField.text else {
      return
    }
    if email.contains("!") {
      emailErrorInfo.text = "Invalid character"
    }
  }
}

This will create a view, and once the user input a invalid character such as !, the error message will display.

Functional programming example 1

However, there are few problems with above method:

1, When user delete the ! in the input text field, the error message is still there, which is quite confusing

2, If we have multiple text inputs such as we want to add user's username, mobile phone number and more, we need to add check on the textfield. See the code below:



//
// ViewController.swift
// RXSwiftExercise
//
// Created by Ben Liu on 6/3/2023.
//

import UIKit

class ViewController: UIViewController {

  @IBOutlet weak var emailTextField: UITextField!
  @IBOutlet weak var emailErrorInfo: UILabel!

  @IBOutlet weak var mobileTextField: UITextField!
  @IBOutlet weak var mobileErrorInfo: UILabel!
  override func viewDidLoad() {
    super.viewDidLoad()
    // Do any additional setup after loading the view.


    emailTextField.addTarget(self, action: #selector(emailTextFieldDidChange(_:)), for: .editingChanged)

    mobileTextField.addTarget(self, action: #selector(mobileTextFieldDidChange(_:)), for: .editingChanged)

  }

  @objc func emailTextFieldDidChange(_ textField: UITextField) {
    guard let email = textField.text else {
      return
    }
    if email.contains("!") {
      emailErrorInfo.text = "Invalid character"
    } else {
      emailErrorInfo.text = ""
    }
  }

  @objc func mobileTextFieldDidChange(_ textField: UITextField) {
    guard let email = textField.text else {
      return
    }
    if email.contains("@") {
      mobileErrorInfo.text = "Invalid character"
    } else {
      mobileErrorInfo.text = ""
    }
  }
}

Functional programming 2

There are still some problems that not resolved yet:

1, How to unit test the textfields rules

2, How to handle multiple textfields, i.e. 10 inputs, we have to create 10 TextFieldDidChange methods to deal with that in the worst case.

This stage of Source code can be found on Github.

3, Refactor with RxSwift

Time to show the power of RxSwift:



import UIKit
import RxSwift
import RxCocoa

class ViewController: UIViewController {

  @IBOutlet weak var emailTextField: UITextField!
  @IBOutlet weak var emailErrorInfo: UILabel!

  @IBOutlet weak var mobileTextField: UITextField!
  @IBOutlet weak var mobileErrorInfo: UILabel!

  let disposeBag = DisposeBag()

  override func viewDidLoad() {
    super.viewDidLoad()
    // Do any additional setup after loading the view.

    setupBinding()
  }

  func setupBinding() {
    emailTextField.rx.text.changed.subscribe(onNext: {
      guard let text = $0 else { return }
      self.emailErrorInfo.text = text.contains("!") ? "Invalid character" : ""
    }).disposed(by: disposeBag)


    mobileTextField.rx.text.changed.subscribe(onNext: {
      guard let text = $0 else { return }
      self.mobileErrorInfo.text = text.contains("@") ? "Invalid character" : ""
    }).disposed(by: disposeBag)
  }
}

With just 8 lines, we make the code much simpler and concise. More importantly we can handle as many new textfields as we want, such as user names, address and so on.

4, Test with the textfields

Here since we are using the text change as the source input, it is better to test with the UI test.



import XCTest

final class RXSwiftExerciseUITests: XCTestCase {

  override func setUpWithError() throws {
  }

  override func tearDownWithError() throws {
    // Put teardown code here. This method is called after the invocation of each test method in the class.
  }

  func testTextFields() throws {
    let app = XCUIApplication()
    app.launch()

    // test email
    let emailTextField = app.textFields["email"]
    emailTextField.tap()
    emailTextField.typeText("123")

    let emailErrorLabel = app.staticTexts["emailError"]


    emailTextField.tap()
    emailTextField.typeText("!")
    XCTAssertEqual(emailErrorLabel.label, "Invalid character")

    // test mobile
    let mobileTextField = app.textFields["mobile"]
    mobileTextField.tap()
    mobileTextField.typeText("456")

    let mobileErrorLabel = app.staticTexts["mobileError"]


    mobileTextField.tap()
    mobileTextField.typeText("@")
    XCTAssertEqual(mobileErrorLabel.label, "Invalid character")
  }
}

This stage of Source code can be found on Github.

Compared with Combine

Combine was introduced by Apple in 2019, which is another reactive programming framework comes with iOS 13+. Here are few comparisions:

1, Compatibility

RxSwift has been available since 2015 and supports iOS 8 and later, while Combine only supports iOS 13 and later.

2, API Design

RxSwift is designed to be more flexible and configurable, with a larger number of operators and customization options. On the other hand, Combine has a more concise and streamlined API, with a focus on Swift's built-in functional programming features.

3, Support

There are a large amount of projects already using RxSwift, so getting to know and master RxSwift is a necessary skill to get a job.

What is next

In the next few articles, we will dig more depth into the RxSwift, first start with some core concepts such as what is Observable, Subscriber , Subject and Operator.

Reference

https://needone.app/rxswift-tutorial-part-1/

RunBlocking in Kotlin Coroutine

Ben — Tue, 28 Feb 2023 02:30:38 +0000

In previous post, we have gone through most of the key concepts and methods in Coroutine:

Kotlin Coroutines Table Content

1, Introduction to Coroutine in Kotlin

2, Non-blocking in Kotlin Coroutines

3, Start and Suspend a Coroutine in Kotlin

However, we haven't talked about runBlocking yet, which is a function provided by the kotlinx.coroutines library in Kotlin. It is used to start a new coroutine that runs synchronously on the current thread and blocks the thread until the coroutine completes.

runBlocking is typically used to start a coroutine from a non-coroutine context, such as a main function, a unit test, or a Java method. It allows you to start a coroutine and wait for it to complete without having to manually manage the lifecycle of the coroutine.

Here's an example of how you might use runBlocking to start a coroutine and wait for it to complete:

import kotlinx.coroutines.*

fun main() {
    runBlocking {
        val result = async {
            delay(1000)
            "Hello, World!"
        }
        println(result.await())
    }
}

In this example, the runBlocking function starts a new coroutine that runs on the current thread (the main thread in this case). Inside the coroutine, we use the async function to start another coroutine that sleeps for one second and then returns a string. The await() function is used to wait for the result of the async coroutine and the result is printed out after 1 sec.

It's important to note that runBlocking is a blocking function, so it should be used with caution. It can be useful for small test cases, but for longer-running coroutines it is recommended to use the launch or async functions and manage the lifecycle of the coroutines manually, in order to not block the main thread.

RunBlocking for Unit testing

runBlocking often is used in unit tests to start a coroutine and wait for it to complete. This allows you to test coroutines in a synchronous manner, making it easier to write tests and assert on the results.

Here's an example of how you might use runBlocking in a JUnit test:

import kotlinx.coroutines.*
import org.junit.Test

class MyTests {
    @Test
    fun testCoroutine() = runBlocking {
        val result = async {
            delay(1000)
            "Hello, World!"
        }
        assertEquals("Hello, World!", result.await())
    }
}

In this example, we use the runBlocking function to start a new coroutine in the context of the test method. The coroutine sleeps for 1 sec and returns a string, which is then asserted in the test.

Using runBlocking in unit tests can make it easier to write tests and assert on the results of coroutines, but it's important to be aware that it makes the test synchronous, so it will block the current thread until the coroutine completes. Also, it's important to make sure that your coroutines are properly isolated from other parts of the system, by using Dispatchers.Unconfined or test dispatchers, to avoid unexpected results in your test.

Ref: https://needone.app/runblocking-in-kotlin/

Certificate pinning and Public key pinning

Ben — Tue, 28 Feb 2023 02:21:03 +0000

Certificate pinning and public key pinning are both techniques that are used to enhance the security of a network connection by ensuring that the client trusts only a specific certificate or public key.

Certificate pinning

Certificate pinning is a security technique that is used to ensure that an app is communicating with the correct server. Certificate pinning works by associating a specific certificate or public key with a server, and checking that the certificate or key is being used when the app communicates with the server.

Public key pinning

Public key pinning, on the other hand, is a technique in which the client stores the public key of a trusted server and verifies that the public key presented by the server during the SSL/TLS handshake is the same as the stored public key. If the public key presented by the server does not match the stored public key, the connection is terminated.

Difference between Certificate pinning and Public key pinning

Both used to prevent man-in-the-middle (MITM) attacks, in which an attacker intercepts the communication between the client and the server and presents a fake certificate or public key in an attempt to impersonate the server.
Certificate pinning may be more effective in some cases, as it verifies the entire certificate chain and all of its associated trust relationships. Public key pinning, on the other hand, only verifies the public key of the server and does not take into account the trust relationships between the server and other certificate authorities.
Public key pinning might be more flexible which only required to check the public key which can be static. With certificate pinning, we need to replace certificates in the app every time when renew them.

Implement certificate pinning

To implement certificate pinning in Swift, you can use the URLSession class and the serverTrustPolicy property of the ServerTrustPolicy enum to configure the trust policy of the session, and the URLSessionDelegate protocol and the urlSession(_:didReceive:completionHandler:) method to evaluate the server trust. Here is an example of how to do this:



import Foundation

class PinningDelegate: NSObject, URLSessionDelegate {
    func urlSession(_ session: URLSession, didReceive challenge: URLAuthenticationChallenge, completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) {
        if challenge.protectionSpace.authenticationMethod == NSURLAuthenticationMethodServerTrust {
            let serverTrust = challenge.protectionSpace.serverTrust
            let certificate = SecTrustGetCertificateAtIndex(serverTrust!, 0)

            if let serverCertificateData = SecCertificateCopyData(certificate!) as Data? {
                // Compare the server certificate data with the trusted certificate data
                if serverCertificateData == trustedCertificateData {
                    let credential = URLCredential(trust: serverTrust!)
                    completionHandler(.useCredential, credential)
                    return
                }
            }
        }

        // Cancel the connection if the server certificate is not trusted
        completionHandler(.cancelAuthenticationChallenge, nil)
    }
}

let delegate = PinningDelegate()

let session = URLSession(configuration: .default, delegate: delegate, delegateQueue: nil)
let url = URL(string: "https://www.example.com")!
let task = session.dataTask(with: url) { data, response, error in
    // Handle the response here
}
task.resume()

In this example, the PinningDelegate class is a delegate of the URLSession class that implements the urlSession(_:didReceive:completionHandler:) method. The method is called when the session receives an authentication challenge from the server, and it is used to evaluate the server trust. The method retrieves the server trust and the server certificate from the challenge, and it compares the server certificate data with the trusted certificate data. If the server certificate is trusted, the method creates a URLCredential object with the server trust and returns it to the session, and the session continues the connection. If the server certificate is not trusted, the method cancels the connection and returns nil

Implement public key pinning

To implement certificate pinning in a Swift app, you can use the ServerTrustPolicyManager and ServerTrustPolicy classes from the Alamofire library. The ServerTrustPolicyManager class allows you to specify a set of trusted certificates or public keys, and the ServerTrustPolicy class allows you to specify the certificate pinning policy for a particular server.

Here is an example of how to use the ServerTrustPolicyManager and ServerTrustPolicy classes to pin a certificate in a Swift app:



import Alamofire

let certificateData = Data(base64Encoded: "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=")!
let certificate = SecCertificateCreateWithData(nil, certificateData as CFData)!
let trustedCertificates = [certificate]
let serverTrustPolicy = ServerTrustPolicy.pinCertificates(certificates: trustedCertificates, validateCertificateChain: true, validateHost: true)
let serverTrustPolicyManager = ServerTrustPolicyManager(policies: ["example.com": serverTrustPolicy])

AF.Session(serverTrustPolicyManager: serverTrustPolicyManager).request("https://example.com").response { response in
    // Handle the response
}

In this example, we use the SecCertificateCreateWithData function to create a SecCertificate object from the certificate data, and add it to an array of trusted certificates. We then use the ServerTrustPolicy.pinCertificates method to create a ServerTrustPolicy object that trusts the specified certificates, and validate the certificate chain and host. We then create a ServerTrustPolicyManager with the ServerTrustPolicy just created.

Further read

Certificate pinning and Public key pinning in Kotlin.

Ref: https://needone.app/certifate-pinning-public-key-pinning/

Encode URL in Kotlin

Ben — Mon, 27 Feb 2023 22:49:35 +0000

In Kotlin, you can use the URLEncoder class to encode a URL string so that it can be safely transmitted over the internet. The URLEncoder class is part of the Java standard library, and it provides a method called encode that can be used to encode a URL string.

Here's an example of how to use the URLEncoder.encode method to encode a URL string in Kotlin:

import java.net.URLEncoder

fun main() {
    val url = "https://www.example.com?q=hello world"
    val encodedUrl = URLEncoder.encode(url, "UTF-8")
    println(encodedUrl) // prints "https%3A%2F%2Fwww.example.com%3Fq%3Dhello%20world"
}

In this example, we define a URL string that includes a query parameter with a space character. We then use the URLEncoder.encode method to encode the URL string using the UTF-8 character encoding. The encoded URL is then printed to the console.

Overall, the URLEncoder class can be used to encode a URL string in Kotlin, ensuring that it can be safely transmitted over the internet.

Further Read

Certificate pinning and Public key pinning in Kotlin

Ben — Mon, 27 Feb 2023 21:16:16 +0000

With the last article (Certificate pinning and Public key pinning), we know the concept of Certificate pinning and Public key pinning, and how to implement them in iOS. This article will demonstrate how to implement them in Kotlin.

Implement certificate pinning

Certificate pinning is a security technique that involves associating a specific certificate or public key with a particular server. This helps to prevent man-in-the-middle attacks by ensuring that the client only trusts the specific certificate or public key associated with the server, and not any other certificate that may be presented by an attacker.

Here is an example of how to implement certificate pinning in Kotlin using the OkHttp library:

Implement public key pinning

val certificatePinner = CertificatePinner.Builder()
    .add("example.com", "sha256/1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ")
    .build()

val client = OkHttpClient.Builder()
    .certificatePinner(certificatePinner)
    .build()

val request = Request.Builder()
    .url("https://example.com")
    .build()

client.newCall(request).execute()

In this example, we create a CertificatePinner object using the CertificatePinner.Builder class. We add a pin for the example.com domain using the add method, specifying the domain name and the SHA-256 hash of the public key.

Next, we create an OkHttpClient object using the OkHttpClient.Builder class and set the CertificatePinner object using the certificatePinner method.

Finally, we create a Request object using the Request.Builder class and specify the URL of the server. We use the OkHttpClient object to send the request and execute it.

Ref: https://needone.app/certificate-pinning-and-public-key-pinning-in-kotlin/

Download image from URL in Kotlin

Ben — Mon, 20 Feb 2023 23:50:40 +0000

In Android, we can get the image from synchronously and asynchronously, but it is more common to see in the later.

Download image synchronously

To download an image from a URL in Kotlin, you can use the URL class and the readBytes function from the kotlin.io library. The URL class represents a uniform resource locator and provides methods for creating and parsing URLs. The readBytes function can be used to read the contents of a file or a stream as a byte array.

Here's an example of how to use the URL and readBytes to download an image from a URL in Kotlin:

import java.net.URL
import kotlin.io.readBytes

fun main() {
    val url = URL("https://www.example.com/image.png")
    val imageData = url.readBytes()
    // TODO: Save the image data to a file or display it in an ImageView
}

In this example, we create a URL object using the URL of the image as a string. We then use the readBytes function to read the contents of the URL as a byte array. The byte array contains the data for the image, which can then be saved to a file or displayed in an ImageView.

Download image asynchronously

To download an image from a URL in Kotlin asynchronously, you can use a coroutine combined with above method. For more

import kotlinx.coroutines.*
import java.net.URL
import kotlin.io.readBytes

fun main() {
    // Create a new coroutine scope
    val scope = CoroutineScope(Dispatchers.Default)

    // Launch a new coroutine in the scope
    scope.launch {
        val url = URL("https://www.example.com/image.png")
        val imageData = url.readBytes()
        // TODO: Save the image data to a file or display it in an ImageView
    }
}

In this example, we create a new coroutine scope using the Dispatchers.Default dispatcher, which runs the coroutine on a shared background thread pool. We then launch a new coroutine in the scope using the launch function. Inside the coroutine, we create a URL object using the URL of the image as a string and use the readBytes function to read the contents of the URL as a byte array. The byte array contains the data for the image, which can then be saved to a file or displayed in an ImageView.

[System.Serializable] in Unity

Ben — Fri, 17 Feb 2023 19:59:23 +0000

[System.Serializable] is a C# attribute that can be applied to a class, struct, or field to indicate that it can be serialized by Unity's serialization system. By doing which will allow developer to save data locally (or remotely via API) , and reload later. Here's a simple example of how to use the [System.Serializable] attribute:

[System.Serializable]
public class PlayerData
{
    public string name;
    public int score;
    public float health;
}

The reason of using the [System.Serializable] is it can make a custom class Serializable, meaning store and reload from local device in text format, such as Json or xml.

What kind of data can be serialized

This includes:

Basic data types such as int, float, and string
Arrays of basic data types or other serializable objects
Classes that implement the ISerializable interface
Lists, dictionaries, and other collection types that contain serializable objects

However, some other types such as Transform can't be serialized, or custom data type that user define themselves. So how to serialize those kinds of data types?

Serialize advanced data types

To serialize advanced data types such as Transform, we can create a wrapper class to hold the values of a transform that we want to serialize. Here is an example:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class TransformSerialize : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        Debug.Log("transform: " + gameObject.transform);
        SerializableTransform st = new SerializableTransform(gameObject.transform);
        string json = JsonUtility.ToJson(st);
        Debug.Log("transform json: " + json);
        Transform tf = JsonUtility.FromJson<SerializableTransform>(json).DeserializableTransform()
        Debug.Log("transform json to object: " + tf);
    }

    // Update is called once per frame
    void Update()
    {

    }
}


[System.Serializable]
public class SerializableTransform
{
    public Vector3 position;
    public Quaternion rotation;
    public Vector3 scale;

    public SerializableTransform(Transform transform)
    {
        position = transform.position;
        rotation = transform.rotation;
        scale = transform.localScale;
    }

    public Transform DeserializableTransform()
    {
        GameObject tempGamObject = new GameObject();
        Transform newTransform = tempGamObject.transform; 
        newTransform.position = position;
        newTransform.rotation = rotation;
        newTransform.localScale = scale;
        return newTransform;
    }
}

In above script, we have a SerializableTransform which can convert a Transform data Serializable. Also we can have a method which can revert it back DeserializableTransform.

👉 If you want received more stories like this, please subscribe my channel to get the latest update in time.

**Ref: **https://hackingwithunity.com/system-serializable-in-unity/

Introduction to Coroutine in Kotlin

Ben — Wed, 15 Feb 2023 23:29:18 +0000

A Coroutine is a lightweight thread of execution that can be suspended and resumed later. There are already many articles or topics covering this but this post is different, it is simple and can let you get start more easily. It will cover the following parts:

Introduction to Coroutine in Kotlin (This article)
Non-blocking in Kotlin Coroutines
Start and Suspend a Coroutine in Kotlin (Incoming this week)

Overview

Like many other programming languages such as JS, Python, Coroutine is a feature provided by Kotlin that enable us to perform long and time consuming task. In short:

In Kotlin, Coroutines are a way to write asynchronous, non-blocking code in a more sequential, easy-to-read way.

In fact, nothing new techiques here. We can treat Kotlin Coroutine as a framework/library that encapsulates the some common usages while dealing with asynchronization.

Simple examples of using coroutines in Kotlin

To use coroutines in Kotlin, you need to include the kotlinx-coroutines-core library in your project. In your app gradle file (there is only one gradle file under IntelliJ project, or choose the gradle file for app if it is Android project), add the following line:

dependencies {
    testImplementation(kotlin("test-junit"))
    implementation(kotlin("stdlib-jdk8"))
    // add coroutine dependency
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.2")
}

Then, you can use the suspend keyword to mark a function as a coroutine and use the launch or async functions to start a coroutine.

1. Use `launch` to create coroutines

Here is an example of using a coroutine to perform a long-running task in the background:

import kotlinx.coroutines.*

fun main() {
    // Start a coroutine using the launch function
    val job = GlobalScope.launch {
        // Perform a long-running task in the background
        delay(1000L)
        println("Hello, world!")
    }

    // Wait for the coroutine to finish
    runBlocking {
        job.join()
    }
}

https://gist.github.com/arkilis/6cdd2d4ad1d30e5852cd1a46210833e0

In this example, the launch function starts a coroutine in the background and returns a Job object that you can use to wait for the coroutine to finish. The delay function is a suspending function that suspends the coroutine for a given amount of time.

2. Use `async` to create coroutines

Here is an example of using coroutines in Kotlin to perform multiple tasks in parallel and then wait for all of them to finish:

import kotlinx.coroutines.*

fun main() {
    // Start two coroutines using the async function
    val job1 = GlobalScope.async {
        // Perform a long-running task in the background
        delay(1000L)
        println("Task 1")
    }

    val job2 = GlobalScope.async {
        // Perform a different long-running task in the background
        delay(2000L)
        println("Task 2")
    }

    // Wait for both coroutines to finish
    runBlocking {
        job1.await()
        job2.await()
    }
}

In this example, the async function is used to start two coroutines in the background. The await function is used to wait for the coroutines to finish. Because the coroutines are running concurrently, the tasks are performed in parallel and the output is printed in the order that the tasks complete.

The difference between launch and async to start a coroutine

Both of them are commonly used to start a coroutine. The main difference between the two is that launch returns a Job (a non-blocking cancellable future) and does not return a result, while async returns a Deferred (a non-blocking cancellable future with a result) that can be used to obtain the result of the coroutine. Considering the difference, when should use the launch and async to create coroutines:

When you use launch function, the coroutine will run in the background and the function call will return immediately. It is used when the result of the coroutine is not needed.
When you use async function, the coroutine will also run in the background and the function call will return immediately, but it will return a Deferred object on which you can call .await() function to get the result of the coroutine. It is used when the result of the coroutine is needed. For example:

val result = GlobalScope.async {
        return@async URL("https://api.example.com/data").readText()
    }
val data = result.await()
println(data)
// output: {"fact":"A group of cats is called a \u201cclowder.\u201d","length":38}

Summary

Coroutines can make it easier to write concurrent and asynchronous code in Kotlin, it is not some cutting-edge technology but a wrapper of threads provided by Kotlin.

What is more from here? As we know Coroutine is a big topic and few wores can explain all of it. This is the first article of the Coroutine series. If you interested, please subscribe for more coming posts on this:

Non-blocking in Kotlin Coroutines
Start and Suspend a Coroutine in Kotlin (Incoming this week)

To learn more about coroutines and how to use them, you can read the official documentation at https://kotlinlang.org/docs/reference/coroutines/coroutines-guide.html.

Lazy in Kotlin

Ben — Wed, 15 Feb 2023 23:26:53 +0000

In the Kotlin programming language, the term "lazy" typically refers to a type of property or variable that is only initialized when it is first accessed, rather than when the containing object is created. This can be useful for optimizing the performance of an application, by delaying the creation of costly objects until they are actually needed.

For example, consider the following code that defines a LazyProperty class with a lazy property called val:

class LazyProperty {
  val lazy: String by lazy {
    "Hello"
  }
}

In this case, the lazy property will only be initialized when it is first accessed, at which point the lazy block will be executed to compute its value. This means that if the lazy property is never accessed, the expensive computation will never be performed, which can save resources and improve performance.

You can also specify additional parameters for the by lazy delegate, such as the mode which determines whether the property should be initialized eagerly (i.e., when the containing object is created) or lazily (i.e., when the property is first accessed). For example:

class LazyProperty {
  val lazy: String by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
    // some expensive computation
    "Hello"
  }
}

In this case, the lazy property will be initialized using the SYNCHRONIZED thread safety mode, which means that multiple threads can safely access the property without the need for explicit synchronization.

Benefits of using Lazy in Kotlin

There are several benefits to using lazy properties in Kotlin, including improved performance and reduced memory usage.

One of the main benefits of lazy properties is that they can improve the performance of an application by delaying the initialization of costly objects until they are actually needed. For example, if you have an object that takes a long time to create or requires a lot of memory, you can use a lazy property to defer its creation until it is first accessed. This can save resources and improve the overall performance of the application.

Another benefit of lazy properties is that they can help to reduce memory usage by only creating objects when they are actually needed. This is because lazy properties are only initialized when they are first accessed, and are then cached for future use. This means that if a lazy property is never accessed, the object it references will never be created, which can save memory.

Additionally, lazy properties can make your code easier to read and understand, by explicitly separating the initialization of an object from its usage. This can make it clear when and how an object is being created, which can help to prevent mistakes and improve the maintainability of your code.

Overall, lazy properties can be a useful tool for optimizing the performance and memory usage of your Kotlin application, and can make your code easier to read and understand.

Drawbacks of using Lazy in Kotlin

While lazy properties can offer many benefits, there are also some potential drawbacks to consider.

One potential drawback of lazy properties is that they can make your code more complex, by requiring you to use the by lazy delegate and specify a lambda expression for initializing the property. This can add additional overhead to your code, and can make it more difficult to understand for other developers who are not familiar with the concept of lazy properties.

Another potential drawback is that lazy properties can make it more difficult to test your code, since the initialization of a lazy property is deferred until it is first accessed. This can make it challenging to ensure that the property has been properly initialized in your test cases, and can require you to use additional tools or techniques to verify its behavior.

Additionally, lazy properties can introduce potential race conditions in your code if they are not used carefully. For example, if multiple threads try to access a lazy property concurrently, it is possible that the property will be initialized multiple times, which can lead to unexpected behavior and potential errors.

Overall, while lazy properties can offer many benefits, it is important to consider these potential drawbacks and use them carefully in order to avoid potential problems.

What is the difference between GameObject.FindObjectOfType and GetComponent

Ben — Tue, 14 Feb 2023 20:19:21 +0000

In Unity, it is quite often to get a GameObject's component, such RigidBody or collision2D. There are a couple of ways of doing so, and GameObject.FindObjectOfType<>() ,GetComponent<>() are both frequently used.

GameObject.FindObjectOfType<>()

GameObject.FindObjectOfType<>() will search the entire scene for a component of the specified type. Therefore, which is way slower if we have a large amount of game objects in current scene, but it can be useful in some occasions, such as if you need to access a component that is not attached to the same GameObject as the script. For example:

GameManager gm = GameObject.FindObjectOfType<GameManager>();

Get the current GameManager in current scene.

GetComponent<>()

On the other hand, GetComponent<>() is used to obtain component(s) which attached to the same GameObject that the script is attached to. Therefore it is a much faster method to access a component as it only searches the current GameObject and its children. For example:

Rigidbody2D rb = GetComponent<Rigidbody2D>();

Get the Rigidbody2D of current game object.

**👉 If you want received more stories like this, please subscribe my channel to get the latest update in time.

Ref: https://hackingwithunity.com/what-is-the-difference-between-gameobject-findobjectoftype-and-getcomponent/

SceneDelegate

Ben — Tue, 14 Feb 2023 20:03:19 +0000

In iOS, the SceneDelegate is a class that is responsible for managing the scenes in your app. A scene is a discrete unit of your app's user interface, such as a window or tab. The SceneDelegate class provides methods that are called at various points in the lifecycle of a scene, such as when a scene is about to be displayed, or when a scene is about to be destroyed.

The SceneDelegate class is typically used to manage the state of a scene and to respond to events that affect the scene. For example, the SceneDelegate class might be used to manage the size and position of a window, or to respond to changes in the device's orientation.

In general, the SceneDelegate class is an optional part of the iOS app architecture, and you do not need to use it in your app unless you need to manage multiple scenes. If you only have one scene in your app, you can use the AppDelegate class to manage the lifecycle of your app instead.

Remove the SceneDelegate

There might be some reason we probably don't want the SceneDelegate class. To remove the SceneDelegate class from your iOS app, you can follow these steps:

Open your project in Xcode and in the Project Navigator, navigate to the SceneDelegate.swift file and delete it.
In the Project Navigator, navigate to the AppDelegate.swift file.
In the AppDelegate class, remove the UISceneDelegate protocol from the class declaration.
In the AppDelegate class, remove the var window: UIWindow? property.
In the AppDelegate class, remove the following methods:

func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions)

func sceneDidDisconnect(_ scene: UIScene)

func sceneDidBecomeActive(_ scene: UIScene)

func sceneWillResignActive(_ scene: UIScene)

func sceneWillEnterForeground(_ scene: UIScene)

func sceneDidEnterBackground(_ scene: UIScene)

6, In the Info.plist file, remove the UISceneManifest key and its associated dictionary.

After completing these steps, the SceneDelegate class will be removed from your app, and the AppDelegate class will be the only class responsible for managing the lifecycle of your app. However, note that removing the SceneDelegate class will also remove the ability to manage multiple scenes in your app, so you should only do this if you do not need this functionality.

For more detalis: https://needone.app/scenedelegate-in-swift/

Format currency in Swift

Ben — Tue, 14 Feb 2023 19:47:17 +0000

Recently I have done quite an amount of work on formatting currency in Swift project, here are some tricks on how to format number in Swift:

Format currency with auto currency symbol

By using the NumberFormatter class, we can convert numbers into string(s), and vice versa. More conveniently, we can also configure a NumberFormatter object to display currency values in a specific locale with a specific currency symbol automatically. For example, € in European countries, $ in Australia and son on.

let value = 100.0
let currencyFormatter = NumberFormatter()
currencyFormatter.numberStyle = .currency
currencyFormatter.locale = Locale(identifier: "en_US")

let formattedValue = currencyFormatter.string(from: value as NSNumber)
print(formattedValue) // "$100.00"

Format currency with max 2 decimals

Moreover, we can also format the currency values in specific format, such as converting 100.78 to $100.78:

let formatter = NumberFormatter()
formatter.numberStyle = .currency
formatter.minimumFractionDigits = 0
formatter.maximumFractionDigits = 2

let amount1 = 100.78
let formattedAmount1 = formatter.string(from: NSNumber(value: amount1))!

print(formattedAmount1) // Output: "$100.78"

// input is whole amount
let amount2 = 100
let formattedAmount2 = formatter.string(from: NSNumber(value: amount2))!

print(formattedAmount2) // Output: "$100"

// input is whole amount
let amount3 = 100.1
let formattedAmount3 = formatter.string(from: NSNumber(value: amount3))!

print(formattedAmount3) // Output: "$100.1"

minimumFractionDigits meaning if the original value is whole amount or just 1 decimal part, it will only show 0 or 1 decimals, see above examples on amount2 and amount3.

Format currency with always 2 decimals

Bear the above example in mind, we can also set up the formatter which always displaying 2 decimals (or any number of decimals you want) for currency values:

let formatter = NumberFormatter()
formatter.numberStyle = .currency
formatter.minimumFractionDigits = 2
formatter.maximumFractionDigits = 2

let amount = 123456.789
let formattedAmount = formatter.string(from: NSNumber(value: amount))!

print(formattedAmount) // Output: "$123,456.79"

For more details: https://needone.app/format-currency-in-swift/

DEV Community: Ben

2 hours to master RxSwift - Part 1

About this series

Introduce RxSwift

Why need RxSwift

Quick example of using RxSwift

1, Integrate RxSwift framework into project

2, Functional programming way

3, Refactor with RxSwift

4, Test with the textfields

Compared with Combine

1, Compatibility

2, API Design

3, Support

What is next

Reference

RunBlocking in Kotlin Coroutine

RunBlocking for Unit testing

Certificate pinning and Public key pinning

Certificate pinning

Public key pinning

Difference between Certificate pinning and Public key pinning

Implement certificate pinning

Implement public key pinning

Further read

Encode URL in Kotlin

Further Read

Certificate pinning and Public key pinning in Kotlin

Implement certificate pinning

Implement public key pinning

Download image from URL in Kotlin

Download image synchronously

Download image asynchronously

[System.Serializable] in Unity

What kind of data can be serialized

Serialize advanced data types

Introduction to Coroutine in Kotlin

Overview

Simple examples of using coroutines in Kotlin

1. Use launch to create coroutines

2. Use async to create coroutines

The difference between launch and async to start a coroutine

Summary

Lazy in Kotlin

Benefits of using Lazy in Kotlin

Drawbacks of using Lazy in Kotlin

What is the difference between GameObject.FindObjectOfType and GetComponent

GameObject.FindObjectOfType<>()

GetComponent<>()

SceneDelegate

Format currency in Swift

Format currency with auto currency symbol

Format currency with max 2 decimals

Format currency with always 2 decimals

1. Use `launch` to create coroutines

2. Use `async` to create coroutines