UI SDK Configuration and Authentication

// register configuration (AppDelegate) before any usage of the SDK
KarhooUI.set(configuration: KarhooConfig())

// The payment provider's view needs to be instantiated. It can be AdyenPaymentView or BraintreePaymentView depending on the PSP choice
// Adyen integration
val paymentManager = AdyenPaymentManager()
paymentManager.paymentProviderView = AdyenPaymentView()

// Braintree integration
val paymentManager = BraintreePaymentManager()
paymentManager.paymentProviderView = BraintreePaymentView()
  
// Later down the line
val config = KarhooConfig(applicationContext)
config.paymentManager = paymentManager

KarhooUISDK.setConfiguration(config)

struct KarhooConfig: KarhooUISDKConfiguration {
  	static var onUpdateAuthentication: (@escaping () -> Void) -> Void = { $0() }
  
  	var paymentManager: PaymentManager {
        AdyenPaymentManager()
        // OR
        BraintreePaymentManager()
    }
  
	  /// Return `true` if you want `Karhoo UISDK` to use `Add to calendar` feature, allowing users to add scheduled ride to the device main calendar. This feature required host app’s `info.plist` to have `Privacy - Calendars Usage Description` marked as used. If you do not want to modify your `info.plist`, or you don’t want user to see this feature, return `false`.
  	var useAddToCalendarFeature: Bool { 
      true
    }
  
    // logo used on side menu and trip completion pop up
    func logo() -> UIImage {
        return UIImage("")!
    }

    func environment() -> KarhooEnvironment {
        return .sandbox
    }
  
    func authenticationMethod() -> AuthenticationMethod {
        return .karhooUser
    }
  
    func requireSDKAuthentication(callback: @escaping () -> Void) {
        KarhooConfig.onUpdateAuthentication {
            callback()
        }
    }
}

// With this configuration the UISDK can be initialised in your App/SceneDelegate. 
// This will also ensure the network layer (KarhooSDK) is initialised.
import KarhooUISDK

class AppDelegate: UIResponder, UIApplicationDelegate {

    var window: UIWindow?

    func application(_ application: UIApplication,
                     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        KarhooUI.set(configuration: YourCompanyKarhooConfiguration())
       ..
        return true
    }
}

//Where you are setting up the KarhooConfig
KarhooConfig.onUpdateAuthentication = { callback in
//Refresh your own access token in order to ensure a proper validity period for the Karhoo token
//Then use that token to refresh the credentials inside the SDK
	let authService = Karhoo.getAuthService()
   authService.login(token: yourTtoken).execute { result in
		if result.isSuccess() {
			callback()
		} else {
			// Show error
		}
	}
}

class KarhooConfig(val context: Context, private val authMethod: AuthenticationMethod = AuthenticationMethod.KarhooUser()) :
        KarhooUISDKConfiguration {
    override lateinit var paymentManager: PaymentManager
    var sdkAuthenticationRequired: ((callback: () -> Unit) -> Unit)? = null
      
    override fun logo(): Drawable? {
        return context.getDrawable(R.drawable.karhoo_wordmark)
    }

    override fun environment(): KarhooEnvironment {
        KarhooEnvironment.Sandbox()
    }

    override fun simulatePaymentProvider(): Boolean = false

    override fun context(): Context {
        return context
    }

    override fun authenticationMethod(): AuthenticationMethod {
        return authMethod
    }

    override fun analyticsProvider(): AnalyticProvider? {
        return GoogleAnalyticsProvider()
    }

    override suspend fun requireSDKAuthentication(callback: () -> Unit) {
        sdkAuthenticationRequired?.invoke(callback)
    }
}

//Application file
val config = SDKConfig(context = this.applicationContext)
config.sdkAuthenticationRequired = {
	loginInBackground(it, yourToken)
}
KarhooApi.setConfiguration(configuration = config)
  
private var deferredRequests: MutableList<(()-> Unit)> = arrayListOf()
private fun loginInBackground(callback: () -> Unit, token: String) {
	if (!requestedAuthentication) {
		Log.e(TAG, "Need an external authentication")
		requestedAuthentication = true
		deferredRequests.add(callback)

		GlobalScope.launch {
//Refresh your own access token in order to ensure a proper validity period for the Karhoo token
//Then use that token to refresh the credentials inside the SDK 
      KarhooApi.authService.login(token).execute { result ->
        when (result) {
        	is Resource.Success -> {
						Log.e(TAG, "We got a new token from the back-end")
						deferredRequests.map {
							it.invoke()
						}
						deferredRequests.clear()
						requestedAuthentication = false
					}
					is Resource.Failure -> toastErrorMessage(result.error)
 				}
			}
		}
  } else {
    deferredRequests.add(callback)
  }
}

final class KarhooConfig: KarhooUISDKConfiguration {

    static var auth: AuthenticationMethod = .karhooUser

    func environment() -> KarhooEnvironment {
        return .sandbox
    }

    func authenticationMethod() -> AuthenticationMethod {
        return .karhooUser
    }
}

class KarhooConfig(val context: Context) :
        KarhooUISDKConfiguration {

    override fun authenticationMethod(): AuthenticationMethod {
        return AuthenticationMethod.KarhooUser()
    }
}

val userService = KarhooApi.userService
val userLogin = UserLogin(email = "[email protected]", password = "password")

userService.loginUser(userLogin: userLogin).execute { result in
     switch result {
        case .success(let user):
            print("User: \(user)")
        case .failure(let error):
            print("error: \(error.code) \(error.message)")
    }
}

val loginRequest = UserLogin(email = "[email protected]", password = "password"
KarhooApi.userService.loginUser(loginRequest).execute { result ->
   when (result) {
      is Resource.Success -> {
         val userInfo: UserInfo = result.data
         Log.d("Welcome ${userInfo?.firstName}")
         // Proceed to next step
      }
      is Resource.Failure -> {
         if (result.error == KarhooError.UserAlreadyLoggedIn) {
            Log.d("Welcome back")
            // Proceed to next step
         } else {
            Log.d((result.error)
         }
      }
   }
}

struct KarhooConfig: KarhooSDKConfigurationProvider {
 
	func authenticationMethod() -> AuthenticationMethod {
  	let settings = TokenExchangeSettings(clientId: "", scope: "")
    	return .tokenExchange(settings: settings)
   }
}

class KarhooConfig : KarhooSDKConfiguration {
  
    override fun authenticationMethod(): AuthenticationMethod {
    		return AuthenticationMethod.TokenExhange(clientId = "",
        			                                   scope = "") 
		}
}

let authService = Karhoo.getAuthService()

authService.login(token: String).execute(callback: { result in
     switch result {
        case .success(let user):
            print("User: \(user)")
        case .failure(let error):
            print("error: \(error.code) \(error.message)")
    	}
   })
}

val authService = KarhooApi.authService

authService.login(token = "123csXXs").execute { result ->
    when (result) {
        is Resource.Success -> Log.d(result.data) // Handle data
        is Resource.Failure -> Log.d(result.error.internalMessage) //Handle errors
    }
}

struct KarhooConfig: KarhooSDKConfigurationProvider {
  func authenticationMethod() -> AuthenticationMethod {
  	let guestSettings = GuestSettings(identifier: "",
                                    referer: "",
                                    organisationId: "")
    	return .guest(settings: guestSettings)
   }
}

class KarhooConfig : KarhooSDKConfiguration {

	override fun authenticationMethod(): AuthenticationMethod {
    	return AuthenticationMethod.Guest(identifier = "client_identifier", referer = "referer", organisationId = "organisation_id")
  }
}

struct KarhooConfig: KarhooUISDKConfiguration {
    func analytics() -> Analytics {
        KarhooAnalytics()
    }
}

KarhooUISDK.analytics = KarhooAnalytics()

struct KarhooConfig: KarhooUISDKConfiguration {
    var isExplicitTermsAndConditionsConsentRequired: Bool { true }
}

class KarhooConfig : KarhooSDKConfiguration {
  
    override fun isExplicitTermsAndConditionsConsentRequired(): Boolean {
        return true
    }
}

"kh_uisdk_legal_notice_label" = "Legal notice";
"kh_uisdk_legal_notice_link" = "mailto:[email protected]";
"kh_uisdk_legal_notice_text" = "The data collected is electronically processed by Karhoo sending email to %1$@. Your data may need to be translated";
"kh_uisdk_legal_notice_title" = "Flit Technologies";

<string name="kh_uisdk_legal_notice_label">Legal notice</string>
<string name="kh_uisdk_legal_notice_title">Karhoo</string>
<string name="kh_uisdk_legal_notice_link">mailto:[email protected]</string>
<string name="kh_uisdk_legal_notice_text">The data collected is electronically processed by Karhoo sending email to %s. Your data may need to be translated</string>