Creating a custom activity indicator in Swift allows you to tailor the appearance and behavior of your loading spinner to fit the style of your app. Here's a step-by-step guide to creating a simple custom activity indicator using UIView Step 1: Create a New Swift File for the Custom Activity Indicator Create a new Swift file and name it RotatingCirclesView.swift . Add the following code to define a custom UIView subclass for your activity indicator: // // RotatingCirclesView.swift // Welcome In // // Created by Praveen Kumar on 05/09/24. // import UIKit class RotatingCirclesView : UIView { let circle1 = UIView ( frame : CGRect ( x : 20 , y : 20 , width : 60 , height : 60 )) let circle2 = UIView ( frame : CGRect ( x : 120 , y : 20 , width : 60 , height : 60 )) let position : [ CGRect ] = [ CGRect ( x : 30 , y : 20 , width : 60 , height : 60 ), CGRect ( x : 60 , y : 15 ,...
SOLID Principles in Swift - ( Single Responsibility Principle(SRP), Open/Closed Principle, Liskov Substitution Principle, Interface Segregation, Dependency Inversion)
SOLID Principles in Swift
- Single Responsibility Principle
- Open/Closed Principle
- Liskov Substitution Principle
- Interface Segregation
- Dependency Inversion
S - Single Responsibility Principle(SRP)
Single Responsibility Principle (SRP) is that every class, module, or function in a program should have one responsibility(Task) in a program.
Example:- A Simple Class For multiple Responsibility
class SimpleHandler {
func simpleHandle() {
let data = requestToDataAPI()
let array = parseToResponse(data: data)
saveToDatabase(array: array)
}
private func requestToDataAPI() -> Data {
// Network request and wait the response
return Data()
}
private func parseToResponse(data: Data) -> [String] {
// Parse the network response into array
return []
}
private func saveToDatabase(array: [String]) {
// Save parsed response into database
print(array)
}
}
This Simple class perform multiple Responsibility like first network, second parsing data and last loadData Binding data
Example:- It states that every module or Class should have only one responsibility.
class SrpHandler {
let api: APIHandler
let parse: ParsingData
let datahander: DataHandler
init(api: APIHandler,
parse: ParsingData,
datahander: DataHandler) {
self.api = api
self.parse = parse
self.datahander = datahander
}
func handler(){
let data = api.reqDataToApi()
let array = parse.parseResponse(data: data)
datahander.loadDataUI(array: array)
}
}
// Network request and wait the response
class APIHandler {
func reqDataToApi() -> Data{
return Data()
}
}
// Parse the network response into array
class ParsingData {
func parseResponse(data: Data) -> [String]{
return []
}
}
// Save parsed response into database
class DataHandler {
func loadDataUI(array: [String]){
print(array)
}
}
O - Open/Closed Principle
Open means - Open for extension
closed means - closed for modification.
Open for Extension You should be able to extend or change the behavior of a class without effort. mean If you have to change in an existing class or change the behaviour.
Closed For Modification You must extend a class without changing the implematation
L - Liskov Substitution Principle (LSP)
The Liskov Substitution principle :- A Derived class should be substitutable for its base class without affecting the correctness of the program.
Or
If you have a reference to a base class, you should be able to substitute a derived class without breaking the program.
Example: -
import Foundation
class Rectangle {
var width: Double
var height: Double
init(width: Double, height: Double){
self.width = width
self.height = height
}
func calculateArea()-> Double{
return width * height
}
}
class Square: Rectangle {
override var width: Double {
didSet{
height = width
}
}
override var height: Double{
didSet {
width = height
}
}
init(side: Double){
super.init(width: side, height: side)
}
func printArea(rectangle: Rectangle){
let area = rectangle.calculateArea()
print("Area : \(area)")
}
}
let square = Square(side: 10.0)
printArea(rectangle: square)
Comments
Post a Comment