स्विफ्ट में अलमॉफायर एपीआई से जेएसएन प्रतिक्रिया कैसे पार्स करें?


125

निम्नलिखित कोड मैंने लिखा है और मुझे JSON में भी प्रतिक्रिया मिल रही है लेकिन JSON का प्रकार "AnyObject" है और मैं इसे Array में परिवर्तित नहीं कर पा रहा हूं ताकि मैं इसका उपयोग कर सकूं।

Alamofire.request(.POST, "MY URL", parameters:parameters, encoding: .JSON) .responseJSON
{
    (request, response, JSON, error) in

    println(JSON?)
}

मैंने आपके प्रश्न को अस्वीकार नहीं किया, लेकिन मैं मान लेता हूं क्योंकि JSON को पार्स करना एक स्पष्ट, सीधे उत्तर देने के लिए बहुत व्यापक विषय है। SwiftyJSON नामक इस लाइब्रेरी को आज़माएं
इसुरु

@ इट्स इट ओके! मैंने उस लाइब्रेरी को देखा है लेकिन मैं अल्मोफायर का उपयोग कर रहा हूं! लेकिन क्या आप मुझे नमूना कोड भेज सकते हैं जिसमें आपने SwiftyJson का उपयोग किया है? वहाँ कोड मेरे लिए काम नहीं करता है!
डेवलपर

मैं भी Alamofire के साथ SwiftyJSON का उपयोग करता हूं। मैं सिर्फ इस तरह से प्रतिक्रिया पारित करता हूं let data = JSONValue(JSON!)। फिर मैं इस तरह से मान निकाल सकता हूं data["Id"]। स्विफ्टजसन प्रलेखन उन उदाहरणों को प्रदान करता है कि उन प्रकारों को वांछित प्रकारों में कैसे पुनः प्राप्त किया जाए। वास्तव में आपको क्या त्रुटि हो रही है?
इसरू

जवाबों:


160

Swift 2.0 Alamofire 3.0 का जवाब वास्तव में इस तरह दिखना चाहिए:

Alamofire.request(.POST, url, parameters: parameters, encoding:.JSON).responseJSON
{ response in switch response.result {
                case .Success(let JSON):
                    print("Success with JSON: \(JSON)")

                    let response = JSON as! NSDictionary

                    //example if there is an id
                    let userId = response.objectForKey("id")!

                case .Failure(let error):
                    print("Request failed with error: \(error)")
                }
    }

https://github.com/Alamofire/Alamofire/blob/master/Documentation/Alamofire%203.0%20Migration%20Guide.md

Alamofire 4.0 और Swift 3.0 के लिए अद्यतन

Alamofire.request(url, method: .post, parameters: parameters, encoding: JSONEncoding.default)
            .responseJSON { response in
                print(response)
//to get status code
                if let status = response.response?.statusCode {
                    switch(status){
                    case 201:
                        print("example success")
                    default:
                        print("error with response status: \(status)")
                    }
                }
//to get JSON return value
            if let result = response.result.value {
                let JSON = result as! NSDictionary
                print(JSON)
            }

        }

13
आपको JSON की वास्तविक सामग्री कैसे मिलती है? यह किस प्रकार की वस्तु है? डिजाइन और प्रलेखन इतना अस्पष्ट है कि मैं इसका पता नहीं लगा सकता और इंटरनेट पर कोई उदाहरण नहीं खोज सकता ...
एलेक्स वर्डेन

मैंने अपने उत्तर में एक दो पंक्तियाँ जोड़ीं जो मदद करनी चाहिए।
जोसेफ गेरगाटी

@JosephGeraghty कंपाइलर में एन्कोडिंग पैरामीटर परिणाम होने के कारण मुझे बता रहा है कि एक अतिरिक्त तर्क कॉल है ... कोई विचार?
amariduran

@ jch-duran पॉजिटिव नहीं है, लेकिन मुझे कुछ समय पहले ऐसी ही कुछ बातें याद हैं। मुझे लगता है कि पुस्तकालयों को अद्यतन नहीं किए जाने या स्विफ्ट संस्करण के साथ वर्तमान नहीं होने के साथ इसका कुछ करना था। सुनिश्चित करें कि आप नवीनतम संस्करणों पर हैं मदद कर सकते हैं
जोसेफ Geraghty

1
@AlexWorden सहमत, इस पृष्ठ ने मुझे उन सवालों के जवाब देने में मदद की और एक अच्छा समाधान प्रदान किया: github.com/SwiftyJSON/SwiftyJSON
iljn

31

जैसा कि ऊपर उल्लेख आप SwiftyJSON लाइब्रेरी का उपयोग कर सकते हैं और अपने मूल्यों को प्राप्त कर सकते हैं जैसे मैंने नीचे किया है

Alamofire.request(.POST, "MY URL", parameters:parameters, encoding: .JSON) .responseJSON
{
    (request, response, data, error) in

var json = JSON(data: data!)

       println(json)   
       println(json["productList"][1])                 

}

मेरी json उत्पाद सूची स्क्रिप्ट से वापस आती है

{ "productList" :[

{"productName" : "PIZZA","id" : "1","productRate" : "120.00","productDescription" : "PIZZA AT 120Rs","productImage" : "uploads\/pizza.jpeg"},

{"productName" : "BURGER","id" : "2","productRate" : "100.00","productDescription" : "BURGER AT Rs 100","productImage" : "uploads/Burgers.jpg"}    
  ]
}

आउटपुट:

{
  "productName" : "BURGER",
  "id" : "2",
  "productRate" : "100.00",
  "productDescription" : "BURGER AT Rs 100",
  "productImage" : "uploads/Burgers.jpg"
}

मैं स्थापित करने के बाद SwiftyJson चीज का उपयोग करने की कोशिश कर रहा हूं, लेकिन SwiftyJson फ़ाइल में कुछ 300 त्रुटि देता है, क्या किसी ने इस मुद्दे का सामना किया? i ', Xcode संस्करण 6.2, ios संस्करण 8.1, cocoaPods 36 का उपयोग करते हुए जैसा कि [github] ( github.com/SwiftyJSON/SwiftyJSON ) प्रलेखन में उल्लेख किया गया है ।
साशी

2
Dude। त्रुटियाँ क्या हैं? एक अलग प्रश्न पूछें और कुछ विवरण प्रदान करें। SwiftyJSON जादू के समान सुंदर है। हो सके तो इसका इस्तेमाल करें।
ज़िया

वास्तव में जोंस स्ट्रिंग को एक ठोस स्विफ्ट ऑब्जेक्ट में परिवर्तित करना चाहिए ताकि आप स्वाभाविक रूप से प्राकृतिक तरीके से इसका उपयोग कर सकें। उनके स्ट्रिंग नाम से फ़ील्ड एक्सेस करना हास्यास्पद है और त्रुटि की संभावना है।
मफिन मैन

26

स्विफ्ट 3, अलमोफायर 4.4 और स्विफ्टजसन:

Alamofire.request(url, method: .get)
  .responseJSON { response in
      if response.data != nil {
        let json = JSON(data: response.data!)
        let name = json["people"][0]["name"].string
        if name != nil {
          print(name!)
        }
      }
  }

यह JSON इनपुट पार्स करेगा:

{
  people: [
    { name: 'John' },
    { name: 'Dave' }
  ]
}

एक अल्मोफायर स्विफ्टी-JSON- विशिष्ट प्लगइन भी है जो स्पष्ट JSON()रूपांतरण की आवश्यकता को दूर करता है : github.com/SwiftyJSON/Alamofire-SwiftyJSON
Robin Macharg

इससे मुझे मदद मिलती है, लेकिन मुझे JSON पद्धति में कुछ समस्याएँ हुईं क्योंकि अपवाद फेंकता है
iGhost

24

मुझे स्विफ्ट 2 के लिए गिटहब पर जवाब मिला

https://github.com/Alamofire/Alamofire/issues/641

Alamofire.request(.GET, URLString, parameters: ["foo": "bar"])
    .responseJSON { request, response, result in
        switch result {
        case .Success(let JSON):
            print("Success with JSON: \(JSON)")

        case .Failure(let data, let error):
            print("Request failed with error: \(error)")

            if let data = data {
                print("Response data: \(NSString(data: data, encoding: NSUTF8StringEncoding)!)")
            }
        }
    }

3
यह Swift 2.0 + Alamofire JSON पार्सिंग के लिए सही संस्करण है।
साकिब ओमर

5
हम्म मैं अभी भी एक त्रुटि संदेश निर्मित विफल हो रहा हूँ: '(_, _, _) -> शून्य' 'रिस्पांस <AnyObject, NSError> -> शून्य' के लिए परिवर्तनीय नहीं है
एलेक्स

@alex इसका उत्तर देखें कि मैंने इसे हल करने के लिए क्या उपयोग किया था।
जोसफ

आपको बहुत - बहुत धन्यवाद ! आपको पता नहीं है कि सर्वर, जीवन रक्षक से प्रतिक्रिया संदेश को ठीक से प्रदर्शित करने के लिए मैंने कितनी चीजों की कोशिश की!
थिबुत नूह

17

मैं न तो एक JSON विशेषज्ञ हूं और न ही एक स्विफ्ट विशेषज्ञ, लेकिन निम्नलिखित मेरे लिए काम कर रहा है। :) मैंने अपने वर्तमान ऐप से कोड निकाला है, और केवल "MyLog को println" में बदल दिया है, और रिक्त स्थान के साथ इंडेंट करके इसे कोड ब्लॉक के रूप में दिखाने के लिए प्राप्त किया है (उम्मीद है कि मैंने इसे नहीं तोड़ा)।

func getServerCourseVersion(){

    Alamofire.request(.GET,"\(PUBLIC_URL)/vtcver.php")
        .responseJSON { (_,_, JSON, _) in
          if let jsonResult = JSON as? Array<Dictionary<String,String>> {
            let courseName = jsonResult[0]["courseName"]
            let courseVersion = jsonResult[0]["courseVersion"]
            let courseZipFile = jsonResult[0]["courseZipFile"]

            println("JSON:    courseName: \(courseName)")
            println("JSON: courseVersion: \(courseVersion)")
            println("JSON: courseZipFile: \(courseZipFile)")

          }
      }
}

उम्मीद है की यह मदद करेगा।

संपादित करें:

संदर्भ के लिए, यहां बताया गया है कि मेरी PHP स्क्रिप्ट क्या है:

[{"courseName": "Training Title","courseVersion": "1.01","courseZipFile": "101/files.zip"}]

यह चयनित उत्तर होना चाहिए, हालांकि आप इसे अपडेट करना चाह सकते हैं क्योंकि आलमोफायर ने अपने तरीकों को थोड़ा अद्यतन किया है
14

10

स्विफ्ट 3

pod 'Alamofire', '~> 4.4'
pod 'SwiftyJSON'

File json format:
{
    "codeAd": {
        "dateExpire": "2017/12/11",
        "codeRemoveAd":"1231243134"
        }
}

import Alamofire
import SwiftyJSON
    private func downloadJson() {
        Alamofire.request("https://yourlinkdownloadjson/abc").responseJSON { response in
            debugPrint(response)

            if let json = response.data {
                let data = JSON(data: json)
                print("data\(data["codeAd"]["dateExpire"])")
                print("data\(data["codeAd"]["codeRemoveAd"])")
            }
        }
    }

2

मुझे JSON फॉर्मेट में response.result.value (Alamofire responseJSON बंद होने के अंदर) को बदलने का एक तरीका मिला, जिसका उपयोग मैं अपने ऐप में करता हूं।

मैं अल्मोफायर 3 और स्विफ्ट 2.2 का उपयोग कर रहा हूं।

यहाँ मैं उपयोग किया गया कोड है:

    Alamofire.request(.POST, requestString,
                      parameters: parameters,
                      encoding: .JSON,
                      headers: headers).validate(statusCode: 200..<303)
                                       .validate(contentType: ["application/json"])
                                       .responseJSON { (response) in
        NSLog("response = \(response)")

        switch response.result {
        case .Success:
            guard let resultValue = response.result.value else {
                NSLog("Result value in response is nil")
                completionHandler(response: nil)
                return
            }

            let responseJSON = JSON(resultValue)

            // I do any processing this function needs to do with the JSON here

            // Here I call a completionHandler I wrote for the success case
        break
        case .Failure(let error):
            NSLog("Error result: \(error)")
            // Here I call a completionHandler I wrote for the failure case
            return
        }

2

मैं आमतौर पर iOS में JSON को सीरियसली या डिस्क्राइब करने के लिए ग्लॉस लाइब्रेरी का उपयोग करता हूं । उदाहरण के लिए, मेरे पास JSON है जो इस तरह दिखता है:

{"ABDC":[{"AB":"qwerty","CD":"uiop"}],[{"AB":"12334","CD":"asdf"}]}

सबसे पहले, मैं JSON सरणी को ग्लोस संरचना में प्रस्तुत करता हूं:

Struct Struct_Name: Decodable {
   let IJ: String?
   let KL: String?
   init?(json: JSON){
       self.IJ = "AB" <~~ json
       self.KL = "CD" <~~ json
   }
}

और फिर Alamofire responseJSON में, मैं निम्नलिखित कार्य करता हूं:

Alamofire.request(url, method: .get, paramters: parametersURL).validate(contentType: ["application/json"]).responseJSON{ response in
 switch response.result{
   case .success (let data):
    guard let value = data as? JSON,
       let eventsArrayJSON = value["ABDC"] as? [JSON]
    else { fatalError() }
    let struct_name = [Struct_Name].from(jsonArray: eventsArrayJSON)//the JSON deserialization is done here, after this line you can do anything with your JSON
    for i in 0 ..< Int((struct_name?.count)!) {
       print((struct_name?[i].IJ!)!)
       print((struct_name?[i].KL!)!)
    }
    break

   case .failure(let error):
    print("Error: \(error)")
    break
 }
}

ऊपर दिए गए कोड से आउटपुट:

qwerty
uiop
1234
asdf

2

स्विफ्ट 5

class User: Decodable {

    var name: String
    var email: String
    var token: String

    enum CodingKeys: String, CodingKey {
        case name
        case email
        case token
    }

    public required init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.name = try container.decode(String.self, forKey: .name)
        self.email = try container.decode(String.self, forKey: .email)
        self.token = try container.decode(String.self, forKey: .token)
    }
}

Alamofire API

    Alamofire.request("url.endpoint/path", method: .get, parameters: params, encoding: URLEncoding.queryString, headers: nil)
     .validate()
     .responseJSON { response in

        switch (response.result) {

            case .success( _):

            do {
                let users = try JSONDecoder().decode([User].self, from: response.data!)
                print(users)

            } catch let error as NSError {
                print("Failed to load: \(error.localizedDescription)")
            }

             case .failure(let error):
                print("Request error: \(error.localizedDescription)")
         }

1

यह Xcode 10.1 और Swift 4 के साथ बनाया गया था

सही संयोजन "अलमॉफ़ायर" (4.8.1) और "स्विफ्टजसन" (4.2.0)। पहले आपको दोनों फली को स्थापित करना चाहिए

pod 'Alamofire' तथा pod 'SwiftyJSON'

JSON प्रारूप में सर्वर प्रतिक्रिया:

{
  "args": {}, 
  "headers": {
    "Accept": "*/*", 
    "Accept-Encoding": "gzip;q=1.0, compress;q=0.5", 
    "Accept-Language": "en;q=1.0", 
    "Host": "httpbin.org", 
    "User-Agent": "AlamoFire TEST/1.0 (com.ighost.AlamoFire-TEST; build:1; iOS 12.1.0) Alamofire/4.8.1"
  }, 
  "origin": "200.55.140.181, 200.55.140.181", 
  "url": "https://httpbin.org/get"
}

इस मामले में मैं "होस्ट" जानकारी प्रिंट करना चाहता हूं: "होस्ट": "httpbin.org"

Alamofire.request("https://httpbin.org/get").validate().responseJSON { response in
        switch response.result {
        case .success:
            print("Validation Successful)")

            if let json = response.data {
                do{
                    let data = try JSON(data: json)
                    let str = data["headers"]["Host"]
                    print("DATA PARSED: \(str)")
                }
                catch{
                print("JSON Error")
                }

            }
        case .failure(let error):
            print(error)
        }
    }

शांत और खुश संहिता रखें 😎


0

स्विफ्ट 5 में हम पसंद करते हैं, पूरा करने के लिए टाइपेलियास का उपयोग करें। Typlealias कुछ भी नहीं बस कोड को साफ करने के लिए उपयोग करते हैं।

typealias response = (Bool,Any?)->()


static func postCall(_ url : String, param : [String : Any],completion : @escaping response){
    Alamofire.request(url, method: .post, parameters: param, encoding: JSONEncoding.default, headers: [:]).responseJSON { (response) in

        switch response.result {
           case .success(let JSON):
               print("\n\n Success value and JSON: \(JSON)")

           case .failure(let error):
               print("\n\n Request failed with error: \(error)")

           }
    }
}

-10
 pod 'Alamofire'
 pod 'SwiftyJSON'
 pod 'ReachabilitySwift'



import UIKit
import Alamofire
import SwiftyJSON
import SystemConfiguration

class WebServiceHelper: NSObject {

    typealias SuccessHandler = (JSON) -> Void
    typealias FailureHandler = (Error) -> Void

    // MARK: - Internet Connectivity

    class func isConnectedToNetwork() -> Bool {

        var zeroAddress = sockaddr_in()
        zeroAddress.sin_len = UInt8(MemoryLayout<sockaddr_in>.size)
        zeroAddress.sin_family = sa_family_t(AF_INET)

        guard let defaultRouteReachability = withUnsafePointer(to: &zeroAddress, {
            $0.withMemoryRebound(to: sockaddr.self, capacity: 1) {
                SCNetworkReachabilityCreateWithAddress(nil, $0)
            }
        }) else {
            return false
        }

        var flags: SCNetworkReachabilityFlags = []
        if !SCNetworkReachabilityGetFlags(defaultRouteReachability, &flags) {
            return false
        }

        let isReachable = flags.contains(.reachable)
        let needsConnection = flags.contains(.connectionRequired)

        return (isReachable && !needsConnection)
    }

    // MARK: - Helper Methods

    class func getWebServiceCall(_ strURL : String, isShowLoader : Bool, success : @escaping SuccessHandler, failure : @escaping FailureHandler)
    {
        if isConnectedToNetwork() {

            print(strURL)

            if isShowLoader == true {

                AppDelegate.getDelegate().showLoader()
            }

            Alamofire.request(strURL).responseJSON { (resObj) -> Void in

                print(resObj)

                if resObj.result.isSuccess {
                    let resJson = JSON(resObj.result.value!)

                    if isShowLoader == true {
                        AppDelegate.getDelegate().dismissLoader()
                    }

                    debugPrint(resJson)
                    success(resJson)
                }
                if resObj.result.isFailure {
                    let error : Error = resObj.result.error!

                    if isShowLoader == true {
                        AppDelegate.getDelegate().dismissLoader()
                    }
                    debugPrint(error)
                    failure(error)
                }
            }
        }else {


            CommonMethods.showAlertWithError("", strMessage: Messages.NO_NETWORK, withTarget: (AppDelegate.getDelegate().window!.rootViewController)!)
        }
    }

    class func getWebServiceCall(_ strURL : String, params : [String : AnyObject]?, isShowLoader : Bool, success : @escaping SuccessHandler,  failure :@escaping FailureHandler){
        if isConnectedToNetwork() {

            if isShowLoader == true {
                AppDelegate.getDelegate().showLoader()
            }


            Alamofire.request(strURL, method: .get, parameters: params, encoding: JSONEncoding.default, headers: nil).responseJSON(completionHandler: {(resObj) -> Void in

                print(resObj)

                if resObj.result.isSuccess {
                    let resJson = JSON(resObj.result.value!)

                    if isShowLoader == true {
                        AppDelegate.getDelegate().dismissLoader()
                    }

                    success(resJson)
                }
                if resObj.result.isFailure {
                    let error : Error = resObj.result.error!

                    if isShowLoader == true {
                        AppDelegate.getDelegate().dismissLoader()
                    }

                    failure(error)
                }

            })
        }
    else {

            CommonMethods.showAlertWithError("", strMessage: Messages.NO_NETWORK, withTarget: (AppDelegate.getDelegate().window!.rootViewController)!)
    }

    }



    class func postWebServiceCall(_ strURL : String, params : [String : AnyObject]?, isShowLoader : Bool, success : @escaping SuccessHandler, failure :@escaping FailureHandler)
    {
        if isConnectedToNetwork()
        {

            if isShowLoader == true
            {
                AppDelegate.getDelegate().showLoader()
            }

            Alamofire.request(strURL, method: .post, parameters: params, encoding: JSONEncoding.default, headers: nil).responseJSON(completionHandler: {(resObj) -> Void in

                print(resObj)

                if resObj.result.isSuccess
                {
                    let resJson = JSON(resObj.result.value!)

                    if isShowLoader == true
                    {
                        AppDelegate.getDelegate().dismissLoader()
                    }

                    success(resJson)
                }

                if resObj.result.isFailure
                {
                    let error : Error = resObj.result.error!

                    if isShowLoader == true
                    {
                        AppDelegate.getDelegate().dismissLoader()
                    }

                    failure(error)
                }
            })
        }else {
            CommonMethods.showAlertWithError("", strMessage: Messages.NO_NETWORK, withTarget: (AppDelegate.getDelegate().window!.rootViewController)!)
        }
    }


    class func postWebServiceCallWithImage(_ strURL : String, image : UIImage!, strImageParam : String, params : [String : AnyObject]?, isShowLoader : Bool, success : @escaping SuccessHandler, failure : @escaping FailureHandler)
    {
        if isConnectedToNetwork() {
            if isShowLoader == true
            {
                AppDelegate.getDelegate().showLoader()
            }

            Alamofire.upload(
                multipartFormData: { multipartFormData in
                    if let imageData = UIImageJPEGRepresentation(image, 0.5) {
                        multipartFormData.append(imageData, withName: "Image.jpg")
                    }

                    for (key, value) in params! {

                        let data = value as! String

                        multipartFormData.append(data.data(using: String.Encoding.utf8)!, withName: key)
                        print(multipartFormData)
                    }
                },
                to: strURL,
                encodingCompletion: { encodingResult in
                    switch encodingResult {
                    case .success(let upload, _, _):
                        upload.responseJSON { response in
                            debugPrint(response)
                            //let datastring = String(data: response, encoding: String.Encoding.utf8)
                           // print(datastring)
                        }
                    case .failure(let encodingError):
                        print(encodingError)
                        if isShowLoader == true
                        {
                            AppDelegate.getDelegate().dismissLoader()
                        }

                        let error : NSError = encodingError as NSError
                        failure(error)
                    }

                    switch encodingResult {
                    case .success(let upload, _, _):
                        upload.responseJSON { (response) -> Void in

                            if response.result.isSuccess
                            {
                                let resJson = JSON(response.result.value!)

                                if isShowLoader == true
                                {
                                    AppDelegate.getDelegate().dismissLoader()
                                }

                                success(resJson)
                            }

                            if response.result.isFailure
                            {
                                let error : Error = response.result.error! as Error

                                if isShowLoader == true
                                {
                                    AppDelegate.getDelegate().dismissLoader()
                                }

                                failure(error)
                            }

                        }
                    case .failure(let encodingError):
                        if isShowLoader == true
                        {
                            AppDelegate.getDelegate().dismissLoader()
                        }

                        let error : NSError = encodingError as NSError
                        failure(error)
                    }
                }
            )
        }
        else
        {
            CommonMethods.showAlertWithError("", strMessage: Messages.NO_NETWORK, withTarget: (AppDelegate.getDelegate().window!.rootViewController)!)
        }
    }

}


==================================


Call Method


let aParams : [String : String] = [
                "ReqCode" : Constants.kRequestCodeLogin,
                ]

            WebServiceHelper.postWebServiceCall(Constants.BaseURL, params: aParams as [String : AnyObject]?, isShowLoader: true, success: { (responceObj) in


                if "\(responceObj["RespCode"])" != "1"
                {
                    let alert = UIAlertController(title: Constants.kAppName, message: "\(responceObj["RespMsg"])", preferredStyle: UIAlertControllerStyle.alert)
                    let OKAction = UIAlertAction(title: "OK", style: .default) { (action:UIAlertAction!) in
                    }
                    alert.addAction(OKAction)
                    self.present(alert, animated: true, completion: nil)
                }
                else
                {
                    let aParams : [String : String] = [
                        "Password" : self.dictAddLogin[AddLoginConstants.kPassword]!,
                        ]
                    CommonMethods.saveCustomObject(aParams as AnyObject?, key: Constants.kLoginData)

                }
                }, failure:
                { (error) in

                    CommonMethods.showAlertWithError(Constants.kALERT_TITLE_Error, strMessage: error.localizedDescription,withTarget: (AppDelegate.getDelegate().window!.rootViewController)!)
            })
        }

6
यह सब कोड क्या उपयोगी होगा, इसका स्पष्टीकरण।
पीटर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.