
```swift
/// Key technologies 
ActivityKit / MVVM / UserNotifications / PostgreSQL / Structured Concurrency /
SwiftUI / UIBezierPath / Vapor / Vapor_Queues / XCTest
```

# Release
I published the app to the App Store!🎉  
[App Store Links](https://apps.apple.com/us/app/eyedamage/id1658452227)  

![eyedamage_appstore{700:149/100}](https://user-images.githubusercontent.com/98417271/218229201-1cf45546-8cd4-4745-aeba-0c1c2d888d15.png)

# Introduction

## Backgorund
There are various apps to discourage smartphone use. Some of them discourage smartphone use by giving rewards to users such as character items, based on the amount of time they do not use their phones. But I have had the experience of that backfired because I was looking forward to the rewards. I thought, for some people including me, the inclusion of game elements may in fact cause people rather to be distracted by their phones. And I wondered, instead of rewarding people, If I gave them a punishment based on use time, people would refrain from using their phones.

## Solution
In this app, I feature a creepy eye on lock screen, blood vessels of which bleed according to smartphone usage during bedtime. With Live Activities that was introduced in iOS 16, the application can reflect smartphone usage to the eye icon in real time manner.
In addition, I implemented summary report functionality so that users can identify trends about their smartphone usage time. This will help them to understand when they use their phones too much, how tired their eyes feel when they use them too much, etc.

## Features
- LocalNotifications
- PushNotifications
- LiveActivities
- Local data persistence (Store daily usage reports with FileMnager)

## Requirements
- Swift: version 5.6
- iOS: 16.1 or later
- Vapor: version 4.0

## Repository
[EyeDamage Repository](https://github.com/YIshihara11201/Eye_Damage)

## Usage
1. You will set bed time and wakeup time on the Setting tab.

![setting{300:250/444}](https://user-images.githubusercontent.com/98417271/218219856-cba96af3-0f83-4b6c-8aaa-4eded5d342cf.png)

2. Once you set the time, you will receive notification at the bedtime.  

3. When you tap the notification, time recording starts. After the moment, every time you unlock smartphone (and open the application), the app records the time you start using smartphone.

4. Before you stop using smartphone, you will tap sleep button, which will records the timing you will go to sleep.  

5. At the same timing as 3., Live Activity is triggered and you will see an eye on the lock screen, which will bloodshoot as you spend time using smartphone.

![eye{300:250/444}](https://user-images.githubusercontent.com/98417271/217737501-564dccb4-298d-4bb9-b4bc-00f5efdb5986.png)

# Takeaways
## Problem
With default specification, Live Activity is terminated 8 hours after it is triggered. $see [Apple documentation](https://developer.apple.com/documentation/activitykit/displaying-live-data-with-live-activities)$.  
Its state properties are thrown away as well. With this behaviour, when you get up in the morning, you will see an icon saying "you spent 0 min 0 sec" without some devices like the image below.

![initial_eye_state{250:236/100}](https://user-images.githubusercontent.com/98417271/218220218-1973dc07-7619-440b-83ac-3e6ca29bffd6.png)

## Solution for the problem
I solved this problem using silent remote notification and Vapor/Queues.  
The idea is to send a signal 5 minutes before Live Activity is forced to terminated, and thereby retain the eye icon state for next morning.  
While user is sleeping, application will receive a silent notification in the background and use a method to terminate Live Activity in a notification delegate method. This will prevent the lock screen from being reset the next morning.

I used following technologies to achieve this.  
- Vapor/Queues (to schedule a futer task)  
- Silent Remote Notification (notify an application something from server side when user application is not in foreground)  

## 1. Schedule future tasks
With Vapor/Queues, you can set a task regulary or at specific timing.  

- **Job**
Tasks are defined by the Job or AsyncJob protocol.
```swift
struct ActivityInfo: Codable {
  let pushToken: String
}

struct BackgroundLiveActivitiesUpdateJob: AsyncJob {
  typealias Payload = ActivityInfo
  
  func dequeue(_ context: Queues.QueueContext, _ payload: ActivityInfo) async throws {
    // this method will send silent remote notification to a client
    try await APNSManager.sendBackgroundNotification(token: payload.pushToken, client: APNSManager.getClient(), activityInfo: payload)
  }
}
```

- **Registering a Job**
After modeling a job you must add it to your configuration section like this:

```swift
// in configure method, register Job
let bgLiveActivityJob = BackgroundLiveActivitiesUpdateJob()
app.queues.add(bgLiveActivityJob)
```

- **Running Workers in-process**
To run a worker in the same process as your application (as opposed to starting a whole separate server to handle it), call the convenience methods on Application:
```swift
// in configure method, run worker
try app.queues.startInProcessJobs(on: .default)
```

- **Dispatching Jobs**
To dispatch a queue job, you need access to an instance of Application or Request.  
You will most likely be dispatching jobs inside of a route handler:  
With delayUntil argument, you can specify time to trigger the job
```swift
// inside route handler function
try await req.queue.dispatch(
  BackgroundLiveActivitiesUpdateJob.self,
  activityInfo,
  delayUntil: dispatchDate
)
```  
  
## 2. Send Silent Remote Notification
You can receive remote notification using 
```swift
func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any]) async -> UIBackgroundFetchResult 
```

Inside the delegate, I ended the ongoing Live Activity.  
This will keep the eye icon up-to-date even 8 hours after its start.  
```swift
func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any]) async -> UIBackgroundFetchResult {
    await Activities.terminateActivity()
    return .noData // always return no data (regardless termination succeeds or not)
}
```


Eye Damage


```swift
/// Key technologies 
FIleManager / GoogleSignIn / PDFKit / UICollectionView /
UICollectionViewDiffableDataSource / UITableView / UITableViewDiffableDataSource / UIKit / XCTest
```

# Introduction

## Backgorund
The application was designed to replace script-baced invoicing system with more efficient iOS invoicing application. The client requests (implemented functionalities) are as follows.
- Import Google Calender schedules.
- According to the schedules, create invoice pdf for each customer.
- Manually create invoice for a customer.
- At first day of months, generate invoices automatically and send mails.
- Store invoice recods to review income.

## My contribution
QATester / iOS Developer

## Roles

- Refactor untestable codes such that they become testable with various techniques to isolate dependencies.
- Implement Unit/UI tests.
- Create PDF generator with PDFKit to replace existing script-based One.
- Implement some UITableViews & UIColletionViews to display users information fetched from Google Calendar.  
  
---------  
  
# Unit Testing Techniques 
This post mainly describes the knowledge and techniques I used throgh testing.

## FIRST principle
Tests must follow "FIRST" principle  

#### Fast
&nbsp;&nbsp; Tests that takes 1/10th of a second to run is a slow unit test.

#### Isolated
&nbsp;&nbsp; Tests have no side effects that would persist beyond the test run.

#### Repeatable
&nbsp;&nbsp; Calling a function with the same input will always yield the same output.

#### Self-verifying
&nbsp;&nbsp; This means using assertions to pass or fail without human verification.

#### Timely
&nbsp;&nbsp; Tests have more value when written before the production code.

## Test Launch Sequence
How tests are launched?
1. Launch the simulator on macOS.
2. Dynamically inject the test bundle into the app.
3. Launch the app in the simulator.
4. Run the tests.
5. Terminate the app.

This gives tests the ecosystem they need to verify interactions with UIKit.  
As part of step 3, UIKit gives the app delegate a chance to set up anything the app needs to launch. This may include things like the following:  

- Setting up core data
- Sending an app-specific key to an analytics service
- Sending a request to fetch data it needs before going to the first screen

These are things we don’t want to have happen while running unit tests, therefore AppDelegate must be bypassed to prevent unintended side-effect

## Bypass AppDelegate
[https://mokacoding.com/blog/prevent-unit-tests-from-loading-app-delegate-in-swift/](https://mokacoding.com/blog/prevent-unit-tests-from-loading-app-delegate-in-swift/)

```swift
// main.swift
import UIKit

private func delegateClassName() -> String? {
  return NSClassFromString("XCTestCase") == nil ? NSStringFromClass(AppDelegate.self) : nil
}

UIApplicationMain(
  CommandLine.argc,
  CommandLine.unsafeArgv,
  nil,
  delegateClassName()
)

// AppDelegate.swift
import UIKit

class AppDelegate: UIResponder, UIApplicationDelegate {
  // ...
}
```

## Example of Difficult Dependencies
Q) What type of tests are difficult (or untestable)?  
A) Ones violate FIRST principle.  

#### F for Fast
  Examples include the following:  
  - Calls to web services
  - Timers

#### I for Isolated
Globals aren’t a problem if they’re read-only, such as string constants. It’s when we can change the value of a global that we run into the challenges of shared mutable state. One test can set a value that affects a following test.  
  
Examples include the following:

  - Global variables and persistent storage  
  - Variables defined outside of any type
  - Singletons
  - Static properties
  - The file system
  - UserDefaults
  - The keychain
  - A local database
  - A remote database
  
We need each test to run in a clean room.  
Earlier test runs or manual testing should not change the outcome of automated tests.  
And automated tests should leave no trace that affect later manual testing.  

#### R for Repeatable
We expect different results for the following:  

  - Current time or date
  - Camera or microphone input
  - Face ID or Touch ID
  - Core Motion sensors  
  - Random numbers
  - External services they can fail
  - Writing to a log file, we can run out of disk space
  - Time zone of the machine running tests when writing tests
  - Analytics
  - Playing audio or video  

# Isolate Dependencies from test code
This section shows some of techniques to isolate difficult dipendencies from test codes.
## Add Backdoor (conditional compilation to isolate singleton)

```swift
// Before Adding Backdoor

class Singleton {
  static let shared = Singleton()
  func doSomething() {}	
}

func main() {
  Singleton.shared.doSomething()
}
```  

```swift
// Backdoor applied

class MySingleton {
  static var shared: MySingleton {
#if DEBUG
    if let stubbedInstance = stubbedInstance {
      return stubbedInstance
    }
#endif
    return instance
  }
	
#if DEBUG
  static var stubbedInstance: MySingleton?
#endif
  
  static let instance = MySingleton()
  func doSomething() {} 
}

func main() {
  MySingleton.stubbedInstance = MySingleton()
  MySingleton.shared.doSomething()
}
```
Note:  
Use this technique when you own singletons.  
But in general, you should avoid mixing test code into production code.  
Conditional compilation makes code hard to read, reason about, and maintain.  

## Subclass and Override (add a layer of indirection around singleton)
```swift
// Before Subclassing and Overriding

class Act {
  static let shared = Act()
  func doSomething() {}
}

class ExampleVC: UIViewController {
  override func viewDidAppear(_ animated: Bool) {
    super.viewDidAppear(animated)
    Act.shared.doSomething()
  }
}

class ExampleVCTests: XCTestCase {
  func test_viewDidAppear() {
    let sut = ExampleVC() // this contains singleton, violates isolation principle
      sut.loadViewIfNeeded()
      sut.viewDidAppear(false)
   }
}
```

```swift
// Subclassing and Overriding applied

class Act {
  static let shared = Act()
  func doSomething() {}
}

// extract singleton to method for later overriding
class ExampleVC: UIViewController {
  func act() -> Act { Act.shared }
  override func viewDidAppear(_ animated: Bool) {
    super.viewDidAppear(animated)
    Act.shared.doSomething()
  }
}

class TestableOverrideVC: ExampleVC {
  override func act() -> Act {
    Act()
  }
}

class OverrideVCTests: XCTestCase {
  func test_viewDidAppear() {
    let sut = TestableOverrideVC() // singleton is isolated now
    sut.loadViewIfNeeded()
    sut.viewDidAppear(false)
  }
}
```
Note  
Use this technique when do not you own singletons. 

The idea is to create a subclass of production code that lives only in test code, or a test-specific subclass.  
It gives us a way to override methods that are problematic for testing.

Subclass and Override Method can only be applied to a class that permits subclassing:  
- Swift doesn’t allow subclassing of structs.
- The final modifier prevents classes from having subclasses. Remove it to apply this technique.
- Storyboard-based view controllers can’t be subclassed because the storyboard stores an instance of a predetermined type.  
  

## Inject Instances Through Properties
```swift
// Dependency injection(through property) applied

class InstancePropertyVC: UIViewController {
  lazy var act = Act.shared
  
  override func viewDidAppear(_ animated: Bool) {
    super.viewDidAppear(animated)
    act.doSomething()
  }
}

class InstancePropertyVCTests: XCTestCase {
  func test_viewDidAppear() {
    let sut = InstancePropertyVC()
    sut.act = Act() // singleton is isolated now
    sut.loadViewIfNeeded()
    sut.viewDidAppear(false)
  }
}
```
  
  
## Extract protocol and inject Fake object
```swift
// Extract behaviour into protocol for a dependency(persistence, etc...)

protocol UserDefaultsProtocol {
  func object(forKey defaultName: String) -> Any?
  func set(_ value: Any?, forKey defaultName: String)
  func value(forKey key: String) -> Any?
}
```

```swift
// Define Fake-class implementing the protocol

class FakeUserDefaults: UserDefaultsProtocol {
  var store: [String: Any] = [:]
  
  func object(forKey defaultName: String) -> Any? {
    if let obj = store[defaultName] {
      return obj
    }
    
    return nil
  }
  
  func set(_ value: Any?, forKey defaultName: String) {
    store[defaultName] = value
  }
  
  func value(forKey key: String) -> Any? {
    if let val = store[key] {
      return val
    }
    
    return nil
  }
}
```

```swift
// Declare the dependency as a Protocol-type variable inside main Class

class ExampleViewModel: ObservableObject {
  let userDefaults: UserDefaultsProtocol = UserDefaults.standard
}
```

```swift
// Replace dependency with Fake inside test code

final class ExampleViewModelTests: XCTesst {
  private var sut: ExampleViewModel!
  
  override func setUpWithError() throws {
    try super.setUpWithError()
    sut = ExampleViewModel()
    sut.userDefaults = FakeUserDefaults()
  }
}
```  
  
  
## Wrapper class
Built-in methods like Data().write(url: URL) have persisting side-effect throughout Tests.  
Suppose that Data() is an output of another built-in method, it cannot be replaced with protocol-type object.  
In this situation, using wrapper class, you can add indirection layer and seperate dependencies.  

```swift
// Before removing dependency

struct SomeViewModel: ObservableObject {
  static func getData() -> Data {
    ...
  }
  
  static func write(url: URL) throws {
    let data = getData()
    try data.write(to: url) // this has side effect to test environment, which violates FIRST principle (I for Isolation)
  }
}

// Test code
final class SomeViewModelTests: XCTesst {
  private var sut: SomeViewModel!
  
  override func setUpWithError() throws {
    try super.setUpWithError()
    sut = SomeViewModel()
  }

  ...
  
  func test_write() throws {
    try sut.write(url: URL(fileURLWithPath: "dummy_path")) // this is not testable as having persisting side-effect
  }
}
```

```swift
// Introduce Wrapper class for Data class

protocol DataHandlerProtocol {
  func write(data: Data, url: URL, options: Data.WritingOptions) throws
}

class DataHandler: DataHandlerProtocol {
  func write(data: Data, url: URL, options: Data.WritingOptions) throws {
    try data.write(to: url, options: options)
  }
}
```

```swift
// declare Wrapper class in production code

struct SomeViewModel: ObservableObject {
  static var dataHandler: DataHandlerProtocol = DataHandler()
  
  static func getData() -> Data {
    ...
  }
  
  static func saveFile(url: URL) throws {
    let data = getData()
    try dataHandler.write(data: data, url: fileURL, options: []) // use wrapper object
  }
}
```

```swift
// Create Fake Wrapper class and inject to test code

class FakeDataHandler: DataHandlerProtocol {
  var files: [String: Data] = [:] // use local variable as a storage, instead of persisting store
  
  func write(data: Data, url: URL, options: Data.WritingOptions) throws { 
    files[url.absoluteString] = data
  }	
}

// Test code
final class SomeViewModelTests: XCTesst {

  private var sut: SomeViewModel!
  
  override func setUpWithError() throws {
    try super.setUpWithError()
    sut = SomeViewModel()
    sut.dataHandler = FakeDataHandler() // dependency is removed!
  }
 
  ...
  
  func test_write() throws {
    let data = sut.getData()
    try sut.write(data: data, url: URL(fileURLWithPath: "dummy_path"), options: [])

    XCTAssertEqual(sut.files.first, data)
  }
}
```


Invoice Manager


```swift
/// Key technologies 
GCD / MVVM / UserNotifications / PostgreSQL /
Structured Concurrency / SwiftUI / Vapor / WebSockets
```

# Release
I published the app to the App Store!🎉  
[App Store Links](https://apps.apple.com/us/app/lets-switch/id1662123590)  

![App Store screenshots{700:157/100}](https://user-images.githubusercontent.com/98417271/218228757-01e623f4-418a-4884-903f-4f5dd93bff9d.png)  

# Introduction

## Backgorund
Switching tasks is always hard, especially you are studying, learning new things on your own. Once you finish studying math, you must feel unwilling to start reading history textbook. Without some kind of pressure, switching tasks is painstaking. I always feel guilty after realizing how valuable the time I was procrastinating was.

## Solution
This application takes advantage of peer pressure that you gain when you declare to do something in front of others. You will register your task in advance for some time slots in a day to match other user’s task. When the time comes, you are invited to matching room, there, you can send and receive ale to and from your partner, which will boost your motivation.

## Features
- PushNotifications
- WebSockets
- Database management for task scheduling with Vapor

## Requirements
- Swift: version 5.6
- iOS: 16.1 or later
- Vapor: version 4.0

## Repository
  [Let's Switch Repository](https://github.com/YIshihara11201/Lets_Switch)

# Usage

1. You will register a task. According to registration state, you will see different messages.


![slots{700:194/100}](https://user-images.githubusercontent.com/98417271/217910252-30dd857f-5a7b-4ea6-b293-41a8927171fe.png)

2. One minute before the registered time, you will receive push notification and can enter the matching room.

3. In the matching room, you and your partner can send ale to cheer up each other.

![demo{250:100/216}](https://user-images.githubusercontent.com/98417271/218219662-45b462de-f01c-4d3a-9c21-6249fc50ba26.gif)

4. You made a commitment, and will have no way to procrastinate switching tasks.

# Takeaways

Actual implementation considering dividing websocket rooms
```swift
// Server side implementation

enum WebSocketSendOption {
  case sender(WebSocket), all((WebSocket, UUID))
}

class WebSocketController {
  var clients: [UUID: [WebSocket]] // seperate websocket room according to id
  
  init() {
    self.clients = [:]
  }
  
  func webSocket(req: Request, socket: WebSocket) {
    let id = req.query[UUID.self, at: "id"]!
    self.connect(socket, id: id)
  }
  
  func connect(_ ws: WebSocket, id: UUID) { // register a client to room (specified by id)
    if clients[id] == nil {
      clients[id] = []
    } else {
      clients[id] = clients[id]!.filter({
        !$0.isClosed
      })
      
      if clients[id] == nil {
        clients[id] = []
      }
    }
    
    clients[id]!.append(ws)
    
    ws.onBinary { [weak self] ws, buffer in
      guard let self = self, 
            let data = buffer.getData(at: buffer.readerIndex, length: buffer.readableBytes) else { 
              return
            }
      self.onData(ws, data)
    }
    
    ws.onText { [weak self] ws, text in
      guard let self = self, let data = text.data(using: .utf8) else { return }
      self.onData(ws, data)
    }
		
    self.send(message: Handshake(), to: .sender(ws))
  }
  
  func send<T: Codable>(message: T, to sendOption: WebSocketSendOption) {
    do {
      let targets: [WebSocket] = {
        switch sendOption {
          case .sender(let ws):         // send to single client
            return [ws]
          case .all((let ws, let id)):  // send to all clients in the room of id
            guard let clients = clients[id] else {
              return []
            }
            
            // skip send to self
            return clients.filter { $0 !== ws }
        }
      }()
      
      let encoder = JSONEncoder()
      let data = try encoder.encode(message)
			
      targets.forEach {
        $0.send(raw: data, opcode: .binary)
      }
    } catch {
      logger.report(error: error)
    }
  }
	
  func onData(_ ws: WebSocket, _ data: Data) {
    let decoder = JSONDecoder()
    do {
      let sinData = try decoder.decode(SinData.self, from: data)
      switch sinData.type {
        case .ale:
          guard let id = UUID(uuidString: try decoder.decode(Ale.self, from: data).id) else { break }
          send(message: AleResponse(), to: .all((ws, id)))
        default:
          break
      }
    } catch {
      fatalError("\(error)")
    }
  }
}

extension WebSocketController: RouteCollection {
  func boot(routes: RoutesBuilder) throws {
    routes.webSocket("socket", onUpgrade: self.webSocket)
  }
}
```

```swift
// Client side implementation

final class WebSocketController {
  private let wsURLString = "someurl.ca"
  private let session: URLSession
  private let decoder = JSONDecoder()
  private let encoder = JSONEncoder()
  
  var socket: URLSessionWebSocketTask!
  var id: UUID
	
  init(id: UUID) {
    self.id = id
    self.session = URLSession(configuration: .default)
  }
  
  func connect() {
    self.socket = session.webSocketTask(with: URL(string: "ws://\(wsURLString)/socket?id=\(id)")!)
    self.listen()
    self.socket.resume()
  }
  
  func listen() {
    self.socket.receive { [weak self] (result) in
      guard let self = self else { return }
      switch result {
        case .failure(let error):
          print(error)
          self.socket.cancel(with: .goingAway, reason: nil)
          self.connect()
          return
        case .success(let message):
          switch message {
            case .data(let data):
              self.handle(data)
            case .string(let str):
              guard let data = str.data(using: .utf8) else { return }
              self.handle(data)
            @unknown default:
              break
          }
        }
        
      self.listen() // once communication successed, prepare for next one
    }
  }
  
  func handle(_ data: Data) {
    do {
      let sinData = try decoder.decode(SinData.self, from: data)
      switch sinData.type {
        case .handshake:
          print("Shook the hand")
        case .aleResponse:
          self.handleAleResponse()
        default:
          break
      }
    } catch {
      print(error)
    }
  }
  
  func handleAleResponse() {
    print("handling ale")
    DispatchQueue.main.async {
      // notify the application that it received an ale message from websocket communication
      NotificationCenter.default.post(name: Notification.Name.thumbsUpReceivedNotification, object: nil) 
    }
  }
  
  func sendAle() {
    let message = Ale(id: id.uuidString)
    do {
      let data = try encoder.encode(message)
        self.socket.send(.data(data)) { (err) in
          if err != nil {
            print(err.debugDescription)
          }
        }
    } catch {
      print(error)
    }
  }
}

// Websocket Communication types
enum MessageType: String, Codable {
  case handshake, ale, aleResponse
}

struct SinData: Codable {
  let type: MessageType
}

struct Handshake: Codable {
  var type = MessageType.handshake
}

struct Ale: Codable {
  var type = MessageType.ale
  var id: String
}

struct AleResponse: Codable {
  var type = MessageType.aleResponse
}
```
