Apple iOS SDK Tap to Pay

import YavinSDK

let yavinSdk = YavinManager.shared

struct  MySwiftUIView: View {    
		@State  private var currentViewController: UIViewController?    
		var  body: some  View {        
				VStack {            
						// Use `currentViewController` to launch Yavin features        
				}        
				.background(            
						ViewControllerAccessor { vc in                
								self.currentViewController = vc
			      }        
		    )
		}
}

YavinManager.shared.showTapToPayActivationFlow(
	viewController: currentViewController,
	onDismiss: {},
	returnApiKey: false,
  onCompletion: { result in
	  switch result {
				case .success(let loginResult):
					if loginResult.success {
							// SDK is logged in, payments can be processed
					}
				case .failure(let error):
					// handle error
			}
	}
)

let request = YavinLoginRequest(    
		yavinApiKey: "your_yavin_api_key"
)

YavinManager.shared.login(    
		viewController: self,    
		request: request
) { result in    
		switch result {    
		case .success(let loginResult):        
				if loginResult.success {
            // Handle successful login
        }   
		case .failure(let error):        
				// Handle error    
		}
}

YavinManager.shared.refreshLogin(viewController: self) { result in    
		switch result {    
		case .success(let loginResult):        
				if loginResult.success {
            // Handle successful login
        }  
		case .failure(let error):        
				// Handle error    
		}
}

// Boolean check
let isLoggedIn = YavinManager.shared.isLoggedIn()

// Publisher for reactive updates
var cancellables = Set<AnyCancellable>()
YavinManager.shared.isLoggedIn()
    .sink { isLoggedIn in
        // Update UI
    }
    .store(in: &cancellables)

YavinManager.shared.logout()

let paymentRequest = YavinPaymentRequest(    
		amount: 1000, // In cents: 10€
		transactionType: .debit,
		reference: "my reference"
)

YavinManager.shared.launchPaymentRequest(    
		viewController: self,    
		request: paymentRequest
) { result in    
		switch result {    
		case .success(let paymentResult):        
				// Handle processed payment
        print("payment with id \(paymentResult.transactionId) processed")   
		case .failure(let error):        
				// Handle payment error    
			}
}

let paymentRequest = YavinPaymentRequest(    
		amount: 1000, // In cents: 10€
		transactionType: .reversal
)

YavinManager.shared.launchPaymentRequest(    
		viewController: self,    
		request: paymentRequest
) { result in    
		switch result {    
		case .success(let paymentResult):        
				// Handle processed payment
        print("payment with id \(paymentResult.transactionId) processed")   
		case .failure(let error):        
				// Handle payment error    
			}
}

YavinManager.shared.enableTipsScreen(enable: true)

if YavinManager.shared.isDeviceEligible() {
    // Device supports Tap to Pay
} else {
    // Device doesn't meet requirements
}

NavigationLink(destination: YavinManager.shared.YavinEligibilityView()) {
    VStack(alignment: .leading) {
        Text("Eligibility")
            .foregroundStyle(.black)
        Text("SoftPos requirements")
            .font(.footnote)
            .foregroundStyle(.gray)
    }
}

Task {    
		await YavinManager.shared.showTapToPayTutorial(viewController: self)
}

YavinManager.shared.prepareProximityReader()

public struct YavinLoginRequest {
    public let yavinApiKey: String?
}

public struct YavinLoginResult {
    public let success: Bool
    public let apiKey: String? // filled when returnApiKey is true
}

public enum YavinLoginError: Error, Sendable, Hashable {
    case deviceNotEligible(message: String? = nil)
    case invalidCredentials(message: String? = nil)
    case loginYavinFailed(message: String? = nil)
    case loginGatewayFailed(message: String? = nil)
    case refreshLoginForbidden(message: String? = nil)
    case tapToPayDisabled(message: String? = nil)
    case invalidPaymentContract(message: String? = nil)
    case tapToPayTermsNotGranted(message: String? = nil)
}

public struct YavinPaymentRequest {
    public let amount: Int
    public let transactionType: YavinTransactionType
    public let currency: String
    public let reference: String?
    public let idempotentUuid: String?
    
    public init(
        amount: Int,
        transactionType: YavinTransactionType,
        currency: String? = "EUR",
        reference: String? = nil,
        idempotentUuid: String? = nil
    ) {
        self.amount = amount
        self.transactionType = transactionType
        self.currency = currency ?? "EUR"
        self.reference = reference
        self.idempotentUuid = idempotentUuid
    }
}

public struct YavinPaymentResult: Hashable {
    public let success: Bool
    public let transactionId: String?
    public let amount: Int
    public let giftAmount: Int
    public let totalAmount: Int
    public let transactionType: YavinTransactionType
    public let currency: String
    public let requiresSignature: Bool
    public let deviceTimestamp: Int?
    public let ticketUrl: String?
    public let issuer: String?
    public let scheme: String?
    public let reference: String?
    public let idempotentUuid: String?
    public let cardToken: String?
    public let paymentApplication: String?
    public let clientTicket: String?
    public let companyTicket: String?
}

public enum YavinPaymentError: Error, Sendable {
    case deviceNotEligible(message: String? = nil)
    case notLoggedIn(message: String? = nil)
    case cancelByUser(message: String? = nil)
    case illegalTransactionState(message: String? = nil)
    case paymentFailed(message: String? = nil)
}