web-dev-qa-db-de.com

Wie wird der Aktivitätsindikator angezeigt, während tableView geladen wird?

Wenn ich zwischen meinen Registerkarten wechsle, werden einige Sekunden geladen, und ich möchte wissen, dass meine Daten geladen werden. Dafür habe ich beschlossen, einen Aktivitätsindikator hinzuzufügen.

Ich habe eine kleine Funktion geschrieben:

func showActivityIndicator() {
    dispatch_async(dispatch_get_main_queue()) {
        self.spinner = UIActivityIndicatorView(activityIndicatorStyle: .WhiteLarge)
        self.spinner.frame = CGRect(x: 0.0, y: 0.0, width: 80.0, height: 80.0)
        self.spinner.center = CGPoint(x:self.loadingView.bounds.size.width / 2, y:self.loadingView.bounds.size.height / 2)

        self.loadingView.addSubview(self.spinner)
        self.view.addSubview(self.loadingView)
        self.spinner.startAnimating()
    }
}

das wird meinen Indikator zeigen. Und versuche es zu benutzen, wenn ich von meinem infoController auf die Schaltfläche tippte:

@IBAction func goToMainFromInfo(sender: AnyObject) {
        self.showActivityIndicator()
        self.performSegueWithIdentifier("fromMainToInfoWActivity", sender: nil)
        self.hideActivityIndicator()
    }
}

Ich zeige es vor der Aufführung und verstecke mich danach. Es hilft mir nicht. Wenn ich versucht habe, Sync zu verwenden:

@IBAction func goToMainFromInfo(sender: AnyObject) {
    dispatch_async(dispatch_get_main_queue()) {
        self.showActivityIndicator()
        self.performSegueWithIdentifier("fromMainToInfoWActivity", sender: nil)
        self.hideActivityIndicator()
    }
}

Aber es hilft auch nicht. Wenn ich die Tabulatortaste drücke, wird die Deckkraft zu 0,5 und ich warte, während sie geladen wird. Ich sehe jedoch keinen Aktivitätsindikator. 

Worin besteht das Problem?

29
Orkhan Alizade

Probieren Sie einfach folgendes aus:

var indicator = UIActivityIndicatorView()

func activityIndicator() {
    indicator = UIActivityIndicatorView(frame: CGRectMake(0, 0, 40, 40))
    indicator.activityIndicatorViewStyle = UIActivityIndicatorViewStyle.Gray
    indicator.center = self.view.center
    self.view.addSubview(indicator)    
}

Und wo Sie mit der Animation beginnen möchten

indicator.startAnimating()
indicator.backgroundColor = UIColor.whiteColor()

Für Stop:

indicator.stopAnimating()
indicator.hidesWhenStopped = true

Hinweis: Vermeiden Sie das Aufrufen von Start- und Stopp gleichzeitig. Geben Sie einfach einige Bedingungen an.

47
Lydia

Swift 3.0

// UIView-Erweiterung

fileprivate var ActivityIndicatorViewAssociativeKey = "ActivityIndicatorViewAssociativeKey"
public extension UIView {
   var activityIndicatorView: UIActivityIndicatorView {
        get {
            if let activityIndicatorView = getAssociatedObject(&ActivityIndicatorViewAssociativeKey) as? UIActivityIndicatorView {
                return activityIndicatorView
            } else {
                let activityIndicatorView = UIActivityIndicatorView(frame: CGRect(x: 0, y: 0, width: 40, height: 40))
                activityIndicatorView.activityIndicatorViewStyle = .gray
                activityIndicatorView.color = .gray
                activityIndicatorView.center = center
                activityIndicatorView.hidesWhenStopped = true
                addSubview(activityIndicatorView)

                setAssociatedObject(activityIndicatorView, associativeKey: &ActivityIndicatorViewAssociativeKey, policy: .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
                return activityIndicatorView
            }
        }

        set {
            addSubview(newValue)
            setAssociatedObject(newValue, associativeKey:&ActivityIndicatorViewAssociativeKey, policy: .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }
    }
}

// NSObject-Erweiterung

public extension NSObject {
    func setAssociatedObject(_ value: AnyObject?, associativeKey: UnsafeRawPointer, policy: objc_AssociationPolicy) {
        if let valueAsAnyObject = value {
            objc_setAssociatedObject(self, associativeKey, valueAsAnyObject, policy)
        }
    }

    func getAssociatedObject(_ associativeKey: UnsafeRawPointer) -> Any? {
        guard let valueAsType = objc_getAssociatedObject(self, associativeKey) else {
            return nil
        }
        return valueAsType
    }
}

Animation starten

tableView.activityIndicatorView.startAnimating()

Animation stoppen

tableView.activityIndicatorView.stopAnimating()

Sie finden mehr Code in Magic

18
broccoli

Swift 2+ 

    class ViewController: UITableViewController {
        weak var activityIndicatorView: UIActivityIndicatorView!

        override func viewDidLoad() {
            super.viewDidLoad()
            let activityIndicatorView = UIActivityIndicatorView(activityIndicatorStyle: UIActivityIndicatorViewStyle.Gray)
            tableView.backgroundView = activityIndicatorView
            self.activityIndicatorView = activityIndicatorView
            activityIndicatorView.startAnimating()

        }
        ...
    }
14
Ragul

Swift  

Platzieren Sie dies unter Ihrer Klasse:

let indicator:UIActivityIndicatorView = UIActivityIndicatorView  (activityIndicatorStyle: UIActivityIndicatorViewStyle.Gray)

Platziere dies in deine loadView ():

indicator.color = UIColor .magentaColor()
indicator.frame = CGRectMake(0.0, 0.0, 10.0, 10.0)
indicator.center = self.view.center
self.view.addSubview(indicator)
indicator.bringSubviewToFront(self.view)
indicator.startAnimating()

In meinem Fall fordere ich Json-Objekte über eine Funktionsanforderung an. Deshalb habe ich diese Funktion am Ende dieser Funktion platziert, um den Aktivitätsindikator zu entfernen, sobald die Daten geladen werden:

self.indicator.stopAnimating()
self.indicator.hidesWhenStopped = true
2
A.J. Hernandez

Ein anderer Ansatz: In meinem Code habe ich eine Erweiterung für UITableView (Swift 2.3) hinzugefügt: 

extension UITableView {
    func activityIndicator(center: CGPoint = CGPointZero, loadingInProgress: Bool) {
        let tag = 12093
        if loadingInProgress {
            var indicator = UIActivityIndicatorView()
            indicator = UIActivityIndicatorView(frame: CGRectMake(0, 0, 40, 40))
            indicator.tag = tag
            indicator.activityIndicatorViewStyle = UIActivityIndicatorViewStyle.WhiteLarge
            indicator.color = //Your color here
            indicator.center = center
            indicator.startAnimating()
            indicator.hidesWhenStopped = true
            self.superview?.addSubview(indicator)
        }else {
             if let indicator = self.superview?.viewWithTag(tag) as? UIActivityIndicatorView { {
                indicator.stopAnimating()
                indicator.removeFromSuperview()
            }
        }
    }
}

Hinweis: Meine Tabellenansicht ist in eine UIView (Superview) eingebettet.

2
Ali Abbas

Dieser Code kann dir helfen :) 

   let indicator:UIActivityIndicatorView = UIActivityIndicatorView  (activityIndicatorStyle: UIActivityIndicatorViewStyle.Gray) 
   indicator.color = UIColor .magentaColor()
   indicator.frame = CGRectMake(0.0, 0.0, 10.0, 10.0)
   indicator.center = self.view.center
   self.view.addSubview(indicator)
   indicator.bringSubviewToFront(self.view)
   indicator.startAnimating()
 func setupSpinner(){
    spinner = UIActivityIndicatorView(frame: CGRect(x: 0, y: 0, width: 40, height:40))
    spinner.color = UIColor(Colors.Accent)
    self.spinner.center = CGPoint(x:UIScreen.main.bounds.size.width / 2, y:UIScreen.main.bounds.size.height / 2)
    self.view.addSubview(spinner)
    spinner.hidesWhenStopped = true
}
1
Ahmed Lotfy

pdate Swift 4.2:

1.Rufen Sie die activityIndicator-Funktion für viewDidLoad auf.
z.B:

var indicator = UIActivityIndicatorView()
override func viewDidLoad() {
    //Initializing the Activity Indicator
    activityIndicator()
    //Starting the Activity Indicator
    indicator.startAnimating()
    //Call Your WebService or API
    callAPI()
}

Hier ist der Code zum Hinzufügen von ActivityIndicator als Unteransicht

func activityIndicator() {
            indicator = UIActivityIndicatorView(frame: CGRect(x: 0, y: 0, width: 40, height: 40))
            indicator.style = UIActivityIndicatorView.Style.whiteLarge
            indicator.color = .red
            indicator.center = self.view.center
            self.view.addSubview(indicator)
    }

2. Führen Sie UI-bezogene Operationen oder API-Aufrufe aus und beenden Sie die Aktivitätsanzeige

    func callAPI() {     
        YourModelClass.fetchResult(someParams, 
        completionHandler: { (response) in 
        //Do necessary UIUpdates
        //And stop Activity Indicator
        self.indicator.stopAnimating()
        })
    }
1
BharathRao

@brocollis Antwort für Swift 4.0. Sie müssen objc _ verwenden, bevor Sie zugeordnete Objekte abrufen oder festlegen. Gemäß der Dokumentation Die APIs zum Abrufen und Festlegen des zugeordneten Objekts in Swift sind:

func objc_getAssociatedObject(object: AnyObject!,
                                 key: UnsafePointer<Void>
                             )  -> AnyObject!

func objc_setAssociatedObject(object: AnyObject!,
                                 key: UnsafePointer<Void>,
                               value: AnyObject!,
                              policy: objc_AssociationPolicy)

Implementierung:

import UIKit

fileprivate var ActivityIndicatorViewAssociativeKey = "ActivityIndicatorViewAssociativeKey"

extension UIView {
    var activityIndicatorView: UIActivityIndicatorView {
        get {
            if let activityIndicatorView = objc_getAssociatedObject(self, &ActivityIndicatorViewAssociativeKey) as? UIActivityIndicatorView {
                return activityIndicatorView
            } else {
                let activityIndicatorView = UIActivityIndicatorView(frame: CGRect(x: 0, y: 0, width: 40, height: 40))
                activityIndicatorView.activityIndicatorViewStyle = .gray
                activityIndicatorView.color = .gray
                activityIndicatorView.center = center
                activityIndicatorView.hidesWhenStopped = true
                addSubview(activityIndicatorView)

                objc_setAssociatedObject(self, &ActivityIndicatorViewAssociativeKey, activityIndicatorView, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
                return activityIndicatorView
            }
        }

        set {
            addSubview(newValue)
            objc_setAssociatedObject(self, &ActivityIndicatorViewAssociativeKey, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }

    }
}
0
apurva kochar

Um den UIActivityIndicator auch über die eventuellen UITableViewController-Separatoren in den Vordergrund zu stellen, habe ich diese Lösung übernommen.

  • Ich habe den UIActivityIndicator programmgesteuert hinzugefügt und als Unteransicht meines UINavigationControllers hinzugefügt

    var activityIndicator: UIActivityIndicatorView!
    
    override func viewDidLoad() {
       super.viewDidLoad()
       // Code
       // .... omissis
    
       // Set activity indicator
       activityIndicator = UIActivityIndicatorView(style: .whiteLarge)
       activityIndicator.color = UIColor.darkGray
       activityIndicator.center = tableView.center
       activityIndicator.hidesWhenStopped = true
       activityIndicator.stopAnimating()
       self.navigationController?.view.addSubview(activityIndicator)
    }
    
  • Ich muss es gerade starten und stoppen, wenn es nötig ist (in meinem Fall): 

    func animateActivityIndicator(_ sender: Any ) {
       guard let vc = sender as? UIViewController else { return }
       if let v = vc as? MyTableViewController {
           if v.activityIndicator.isAnimating {
               v.activityIndicator.stopAnimating()
           } else {
               v.activityIndicator.startAnimating()
           }
       }
       // Others UIViewController or UITableViewController follows...
       // all of them exhibits an activityIndicator variable
       // implemented programmatically or with the storyboard
    }
    

PS. Meine Umgebung ist Xcode 10.0, iOS 12.0

0

Verwenden Sie "Lazy Var". Es ist besser als die Funktion

fileprivate lazy var activityIndicatorView: UIActivityIndicatorView = {
    let activityIndicatorView = UIActivityIndicatorView(activityIndicatorStyle: .gray)
    activityIndicatorView.hidesWhenStopped = true

    // Set Center
    var center = self.view.center
    if let navigationBarFrame = self.navigationController?.navigationBar.frame {
        center.y -= (navigationBarFrame.Origin.y + navigationBarFrame.size.height)
    }
    activityIndicatorView.center = center

    self.view.addSubview(activityIndicatorView)
    return activityIndicatorView
}()

Starten Sie den Spinner einfach überall

so was

func requestData() {
  // Request something
  activityIndicatorView.startAnimating()
}
0
Den Jo