Miscellaneous

private void showAlertError(ApiError apiError) {
    ApiErrorBody errorBody = apiError.getErrorBody();
    int httpCode = apiError.getHttpCode();
    // create AlertDialog with icon and title
    AlertDialog.Builder dialog = new AlertDialog.Builder(this).setIcon(R.drawable.sygnet_synerise);
    if (httpCode != ApiError.UNKNOWN_CODE) {
        dialog.setTitle(String.valueOf(httpCode));
    } else {
        dialog.setTitle(R.string.default_error);
    }
    // append all available messages from API
    if (errorBody != null) {
        List<ApiErrorCause> errorCauses = errorBody.getErrorCauses();
        StringBuilder message = new StringBuilder(errorBody.getMessage());
        if (!errorCauses.isEmpty())
            for (ApiErrorCause errorCause : errorCauses)
                message.append("\n").append(errorCause.getCode()).append(": ").append(errorCause.getMessage());
        dialog.setMessage(message.toString());
    // if there is no available messages, set default one
    } else {
        switch (apiError.getErrorType()) {
            case HTTP_ERROR:
                if (apiError.getHttpErrorCategory() == UNAUTHORIZED) {
                    dialog.setMessage(getString(R.string.error_unauthorized));
                } else {
                    dialog.setMessage(getString(R.string.error_http));
                }
                break;
            case NETWORK_ERROR:
                dialog.setMessage(getString(R.string.error_network));
                break;
            default:
                dialog.setMessage(getString(R.string.error_default));
        }
    }
    // show dialog
    dialog.show();
}

private fun showAlertError(apiError: ApiError) {
    val errorBody = apiError.errorBody
    val httpCode = apiError.httpCode
    // create AlertDialog with icon and title
    val dialog: AlertDialog.Builder = Builder(this).setIcon(R.drawable.sygnet_synerise)
    if (httpCode != ApiError.UNKNOWN_CODE) {
        dialog.setTitle(httpCode.toString())
    } else {
        dialog.setTitle(R.string.default_error)
    }
    // append all available messages from API
    if (errorBody != null) {
        val errorCauses = errorBody.errorCauses
        val message = StringBuilder(errorBody.message!!)
        if (!errorCauses.isEmpty()) for (errorCause in errorCauses) message.append("\n").append(errorCause.code).append(": ").append(errorCause.message)
        dialog.setMessage(message.toString())
        // if there is no available messages, set default one
    } else {
        when (apiError.errorType) {
            ErrorType.HTTP_ERROR -> if (apiError.httpErrorCategory == UNAUTHORIZED) {
                dialog.setMessage(getString(R.string.error_unauthorized))
            } else {
                dialog.setMessage(getString(R.string.error_http))
            }
            ErrorType.NETWORK_ERROR -> dialog.setMessage(getString(R.string.error_network))
            else -> dialog.setMessage(getString(R.string.error_default))
        }
    }
    // show dialog
    dialog.show()
}

func presentAlert(title: String, message: String) {
  let alertController = UIAlertController(title: title, message: message, preferredStyle: .alert)
  let okAction = UIAlertAction(title: "OK", style: .default, handler: nil)
  alertController.addAction(okAction)
  self.present(alertController, animated: true, completion: nil)
}
func showErrorInfo(_ error: NSError, title: String = "Error", debug: Bool = true) {
  if let apiError = error as? SNRApiError {
    var apiErrorDebugInfo: String = String()
    let apiErrorType: SNRApiErrorType = apiError.getType()
    switch (apiErrorType) {
    case .network: apiErrorDebugInfo.append("NETWORK ERROR")
    case .unauthorizedSession: apiErrorDebugInfo.append("UNAUTHORIZED SESSION ERROR")
    case .http: apiErrorDebugInfo.append("HTTP ERROR: \(apiError.getHttpCode())")
    case .unknown: apiErrorDebugInfo.append("UNKNOWN ERROR")
    }
    apiErrorDebugInfo.append("\n\n")
    apiErrorDebugInfo.append("\(apiError.localizedDescription)")
    // first approach
    if let apiErrorCauses = apiError.errors, !apiErrorCauses.isEmpty {
      apiErrorDebugInfo.append("\n\n")
      apiErrorCauses.forEach({ (error) in
        let apiErrorCause: NSError = error as NSError
        var apiErrorCauseString: String = String()
        apiErrorCauseString.append("CODE: \(apiErrorCause.code)")
        apiErrorCauseString.append("\n")
        apiErrorCauseString.append("MESSAGE: \(apiErrorCause.localizedDescription)")
        apiErrorDebugInfo.append(apiErrorCauseString)
        apiErrorDebugInfo.append("\n\n")
      })
    }
    // second approach
    // apiErrorDebugInfo.append("\n\n")
    //
    // let apiErrorCauseString: String = apiError.getBody() ?? ""
    // apiErrorDebugInfo.append(apiErrorCauseString)
    self.presentAlert(title: "Debug SNRApiError", message: apiErrorDebugInfo)
    if debug {
      DebugUtils.print("\(title) \(apiError.code) \(apiError.localizedDescription)")
    }
    return
  }
  if debug {
    DebugUtils.print("\(title) \(error.code) \(error.localizedDescription)")
  }
}
func signIn(email: String, password: String) {
  Client.signIn(email: email, password: password, deviceId: nil, success: { (success) in
    //...
  }, failure: { (error) in
    self.showErrorInfo(error as NSError)
  })
}

[SNRClient signInWithEmail:email password:password deviceId:nil success:^(BOOL isSuccess) {
} failure:^(NSError * _Nonnull error) {
  if ([error isKindOfClass:[SNRApiError class]]) {
    SNRApiError *apiError = (SNRApiError *)error;
    NSLog(apiError.localizedFailureReason) // print information string about all issues
    NSLog(apiError.errors) // print list of error objects about issues that occurred
  }
}];

Future<void> _signInCall(email, password) async {
  await Synerise.client.signIn(email, password).catchError((error) {
  final String errorCode = error.code;
  final String errorMessage = error.message;
  print("Error: $errorCode - $errorMessage");
});
}

Synerise.crashHandlingEnabled(true);

Synerise.crashHandlingEnabled(true)

Synerise.setCrashHandlingEnabled(true)

[SNRSynerise setCrashHandlingEnabled:YES];

Synerise.Initializer()
  .withBaseUrl("YOUR_API_BASE_URL")
  .withClientApiKey('YOUR_CLIENT_API_KEY')
  .withCrashHandlingEnabled(true)
.init();

YourClass cachedModel = (YourClass) CacheManager.getInstance().get(YourClass.class);

val cachedModel: YourClass = CacheManager.getInstance<Any>()[YourClass::class.java] as YourClass

let clientAccountInformation: ClientAccountInformation? = CacheManager.get(ClientAccountInformation.self) as? ClientAccountInformation

SNRClientAccountInformation *clientAccountInformation = [CacheManager get:ClientAccountInformation.class];