How would I create a UIAlertView in Swift?

**For iOS 13 Xcode 11+ Swift 5.X**

`UIAlertController` can now provide Alerts as well as Action Sheets

**Alerts**

// First instantiate the UIAlertController

let alert = UIAlertController(title: "Title",
message: "Message ?",
preferredStyle: .alert)


// Add action buttons to it and attach handler functions if you want to

alert.addAction(UIAlertAction(title: "Cancel", style: .cancel, handler: nil))
alert.addAction(UIAlertAction(title: "Just Do It!", style: .destructive, handler: nil))
alert.addAction(UIAlertAction(title: "Maybe", style: .default, handler: nil))

// Show the alert by presenting it

self.present(alert, animated: true)


Note that it's is a fundamental nature for all action buttons to dismiss the alert view when tapped. The *`style` parameter is just for deciding the color* of the text (and some default order in which the buttons should appear which ofc can be changed)


A sample handler function could be

func handler(_ action: UIAlertAction) {

if action.title == 'Title' {
// do stuff
}

}

As a side note, I would say instead of making 3 different handlers you can just make 1 and trace back to the element which provoked it in the manner shown above
We can also check `alert.style` but that again we can have multiple `.default` styled actions , I wouldn't recommend that


**Action Sheets**

The explanation is similar because the main difference here is that ***an alert interrupts the user whereas an action sheet slides from the bottom in an iPhone*** and appears as a popover in an iPad

The Purpose of action sheets is to guide the users in deciding his actions based on their current state. So you gotta treat action sheets like crossroads !. There is generally no message and the title is rendered as caption sized text

let action = UIAlertController(title: "What do you want to do with the message",
message: nil,
preferredStyle: .actionSheet)

action.addAction(UIAlertAction(title: "Cancel", style: .cancel))

for act in ["Save", "Post", "Discard"] {
action.addAction(UIAlertAction(title: act, style: .default, handler: nil))
}

self.present(action, animated: true)

The above code is going to work for an iPhone but ***will crash at runtime for an iPad*** because `UIPopoverPresentationController` is going to take charge of the alert and it won't be referencing anything at that time. So to avoid that you will have to provide the following chunk of code its mandatory

if let pop = action.popoverPresentationController {

let v = sender as! UIView
pop.sourceView = v
pop.sourceRect = v.bounds
}

Also in case of iPad tapping on anywhere outside the popover will dismiss it and the completion handler of `.cancel` action button will be called.

Hope that helps :) That being said, comment down below if you have any doubts

// Custom Class For UIAlertView

//MARK:- MODULES
import Foundation
import UIKit

//MARK:- CLASS
class Alert : NSObject{

static let shared = Alert()

var okAction : AlertSuccess?
typealias AlertSuccess = (()->())?
var alert: UIAlertController?

/** show */
public func show(title : String?, message : String?, viewController : UIViewController?, okAction : AlertSuccess = nil) {

let version : NSString = UIDevice.current.systemVersion as NSString
if version.doubleValue >= 8 {
alert = UIAlertController(title: title, message: message, preferredStyle:.alert)
alert?.addAction(UIAlertAction(title: "OK", style: .default, handler: { (action: UIAlertAction) in

if let okAction = okAction {
okAction()
}
}))
viewController?.present(alert ?? UIAlertController(), animated:true, completion:nil);
}
}

/** showWithCancelAndOk */
public func showWithCancelAndOk(title : String, okTitle : String, cancelTitle : String, message : String, viewController : UIViewController?, okAction : AlertSuccess = nil, cancelAction : AlertSuccess = nil) {
let version:NSString = UIDevice.current.systemVersion as NSString;

if version.doubleValue >= 8 {
alert = UIAlertController(title: title, message: message, preferredStyle:.alert)

alert?.addAction(UIAlertAction(title: cancelTitle, style: .default, handler: { (action: UIAlertAction) in

if let cancelAction = cancelAction {
cancelAction()
}
}))
alert?.addAction(UIAlertAction(title: okTitle, style: .default, handler: { (action: UIAlertAction) in

if let okAction = okAction {
okAction()
}
}))
viewController?.present(alert!, animated:true, completion:nil);
}
}

/** showWithTimer */
public func showWithTimer(message : String?, viewController : UIViewController?) {

let version : NSString = UIDevice.current.systemVersion as NSString
if version.doubleValue >= 8 {
alert = UIAlertController(title: "", message: message, preferredStyle:.alert)
viewController?.present(alert ?? UIAlertController(), animated:true, completion:nil)
let when = DispatchTime.now() + 1
DispatchQueue.main.asyncAfter(deadline: when){
self.alert?.dismiss(animated: true, completion: nil)
}
}
}
}

Use:-

Alert.shared.show(title: "No Internet Connection", message: "The internet connection appers to be offline.", viewController: self) //without ok action

Alert.shared.show(title: "No Internet Connection", message: "The internet connection appers to be offline.", viewController: self, okAction: {
//ok action
}) // with ok action

Alert.shared.show(title: "No Internet Connection", message: "The internet connection appers to be offline.", viewController: self, okAction: {
//ok action
}, cancelAction: {
//cancel action
}) //with cancel and ok action

Alert.shared.showWithTimer(message : "This is an alert with timer", viewController : self) //with timer

Or just do this
```
let alert = UIAlertController(title: "Alert", message: "Saved Successfully", preferredStyle: UIAlertController.Style.alert)
alert.addAction(UIAlertAction(title: "Ok", style: UIAlertAction.Style.default, handler: nil))
self.present(alert, animated: true, completion: nil)
```

In Swift 4.2 and Xcode 10

**Method 1 :**

**SIMPLE ALERT**

let alert = UIAlertController(title: "Your title", message: "Your message", preferredStyle: .alert)

let ok = UIAlertAction(title: "OK", style: .default, handler: { action in
})
alert.addAction(ok)
let cancel = UIAlertAction(title: "Cancel", style: .default, handler: { action in
})
alert.addAction(cancel)
DispatchQueue.main.async(execute: {
self.present(alert, animated: true)
})

**Method 2 :**

**ALERT WITH SHARED CLASS**

If you want Shared class style(Write once use every where)

import UIKit
class SharedClass: NSObject {//This is shared class
static let sharedInstance = SharedClass()

//Show alert
func alert(view: UIViewController, title: String, message: String) {
let alert = UIAlertController(title: title, message: message, preferredStyle: .alert)
let defaultAction = UIAlertAction(title: "OK", style: .default, handler: { action in
})
alert.addAction(defaultAction)
DispatchQueue.main.async(execute: {
view.present(alert, animated: true)
})
}

private override init() {
}
}

Now call alert like this in every ware

SharedClass.sharedInstance.alert(view: self, title: "Your title here", message: "Your message here")

**Method 3 :**

**PRESENT ALERT TOP OF ALL WINDOWS**

If you want to present alert on top of all views, use this code

func alertWindow(title: String, message: String) {
DispatchQueue.main.async(execute: {
let alertWindow = UIWindow(frame: UIScreen.main.bounds)
alertWindow.rootViewController = UIViewController()
alertWindow.windowLevel = UIWindowLevelAlert + 1

let alert2 = UIAlertController(title: title, message: message, preferredStyle: .alert)
let defaultAction2 = UIAlertAction(title: "OK", style: .default, handler: { action in
})
alert2.addAction(defaultAction2)

alertWindow.makeKeyAndVisible()

alertWindow.rootViewController?.present(alert2, animated: true, completion: nil)
})
}

Function calling

SharedClass.sharedInstance.alertWindow(title:"This your title", message:"This is your message")

**Method 4 :**

**Alert with Extension**

extension UIViewController {

func showAlert(withTitle title: String, withMessage message:String) {
let alert = UIAlertController(title: title, message: message, preferredStyle: .alert)
let ok = UIAlertAction(title: "OK", style: .default, handler: { action in
})
let cancel = UIAlertAction(title: "Cancel", style: .default, handler: { action in
})
alert.addAction(ok)
alert.addAction(cancel)
DispatchQueue.main.async(execute: {
self.present(alert, animated: true)
})
}
}

Now call like this

//Call showAlert function in your class
@IBAction func onClickAlert(_ sender: UIButton) {
showAlert(withTitle:"Your Title Here", withMessage: "YourCustomMessageHere")
}
**Method 5 :**

**ALERT WITH TEXTFIELDS**

If you want to add textfields to alert.

//Global variables
var name:String?
var login:String?

//Call this function like this: alertWithTF()
//Add textfields to alert
func alertWithTF() {

let alert = UIAlertController(title: "Login", message: "Enter username&password", preferredStyle: .alert)
// Login button
let loginAction = UIAlertAction(title: "Login", style: .default, handler: { (action) -> Void in
// Get TextFields text
let usernameTxt = alert.textFields![0]
let passwordTxt = alert.textFields![1]
//Asign textfileds text to our global varibles
self.name = usernameTxt.text
self.login = passwordTxt.text

print("USERNAME: \(self.name!)\nPASSWORD: \(self.login!)")
})

// Cancel button
let cancel = UIAlertAction(title: "Cancel", style: .destructive, handler: { (action) -> Void in })

//1 textField for username
alert.addTextField { (textField: UITextField) in
textField.placeholder = "Enter username"
//If required mention keyboard type, delegates, text sixe and font etc...
//EX:
textField.keyboardType = .default
}

//2nd textField for password
alert.addTextField { (textField: UITextField) in
textField.placeholder = "Enter password"
textField.isSecureTextEntry = true
}

// Add actions
alert.addAction(loginAction)
alert.addAction(cancel)
self.present(alert, animated: true, completion: nil)

}

**Method 6:**

**Alert in SharedClass with Extension**

//This is your shared class
import UIKit

class SharedClass: NSObject {

static let sharedInstance = SharedClass()

//Here write your code....

private override init() {
}
}

//Alert function in shared class
extension UIViewController {
func showAlert(title: String, msg: String) {
DispatchQueue.main.async {
let alert = UIAlertController(title: title, message: msg, preferredStyle: .alert)
alert.addAction(UIAlertAction(title: "OK", style: .default, handler: nil))
self.present(alert, animated: true, completion: nil)
}
}
}

Now call directly like this

self.showAlert(title: "Your title here...", msg: "Your message here...")

**Method 7:**

**Alert with out shared class with Extension in separate class** for alert.

Create one new Swift class, and `import UIKit`. Copy and paste below code.

//This is your Swift new class file
import UIKit
import Foundation

extension UIAlertController {
class func alert(title:String, msg:String, target: UIViewController) {
let alert = UIAlertController(title: title, message: msg, preferredStyle: UIAlertControllerStyle.alert)
alert.addAction(UIAlertAction(title: "Ok", style: UIAlertActionStyle.default) {
(result: UIAlertAction) -> Void in
})
target.present(alert, animated: true, completion: nil)
}
}

Now call alert function like this in all your classes (Single line).

UIAlertController.alert(title:"Title", msg:"Message", target: self)

How is it....

From the `UIAlertView` class:



> // UIAlertView is deprecated. Use **UIAlertController** with a
> preferredStyle of UIAlertControllerStyleAlert instead

On iOS 8, you can do this:

let alert = UIAlertController(title: "Alert", message: "Message", preferredStyle: UIAlertControllerStyle.Alert)
alert.addAction(UIAlertAction(title: "Click", style: UIAlertActionStyle.Default, handler: nil))
self.presentViewController(alert, animated: true, completion: nil)

Now `UIAlertController` is a single class for creating and interacting with what we knew as `UIAlertView`s and `UIActionSheet`s on iOS 8.

**Edit:** To handle actions:

alert.addAction(UIAlertAction(title: "OK", style: .Default, handler: { action in
switch action.style{
case .Default:
print("default")

case .Cancel:
print("cancel")

case .Destructive:
print("destructive")
}
}}))

**Edit for Swift 3:**

let alert = UIAlertController(title: "Alert", message: "Message", preferredStyle: UIAlertControllerStyle.alert)
alert.addAction(UIAlertAction(title: "Click", style: UIAlertActionStyle.default, handler: nil))
self.present(alert, animated: true, completion: nil)


**Edit for Swift 4.x:**

```
let alert = UIAlertController(title: "Alert", message: "Message", preferredStyle: .alert)
alert.addAction(UIAlertAction(title: "OK", style: .default, handler: { action in
switch action.style{
case .default:
print("default")

case .cancel:
print("cancel")

case .destructive:
print("destructive")

}
}))
self.present(alert, animated: true, completion: nil)
```

**AlertView Swift 5 and above:-**



let alert = UIAlertController(title: LocalizedStringConstant.alert, message: message, preferredStyle: UIAlertController.Style.alert)
alert.addAction(UIAlertAction(title: "Retry", style: .cancel, handler: { (_) in
}))
self.present(alert, animated: true, completion: nil)

For above 13.0 version
Using SceneDelegate


For All Kind of Classes

static func showWindowAlert(alertMessage: String, inVC:UIViewController) {
DispatchQueue.main.async(execute: {
guard let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene,
let sceneDelegate = windowScene.delegate as? SceneDelegate
else {
return
}
sceneDelegate.window?.rootViewController = inVC
sceneDelegate.window?.windowLevel = UIWindow.Level.alert + 1

let alert2 = UIAlertController(title: App_Name, message: alertMessage, preferredStyle: .alert)
let defaultAction2 = UIAlertAction(title: "OK", style: .default, handler: { action in
})
alert2.addAction(defaultAction2)

sceneDelegate.window?.makeKeyAndVisible()

sceneDelegate.window?.rootViewController?.present(alert2, animated: true, completion: nil)
})
}