Showing posts with label networking. Show all posts
Showing posts with label networking. Show all posts

Friday, July 3, 2015

RSNetworking 2

I would like to announce the release of RSNetworking 2 for Swift 2.  RSNetworking 2 has all the same great features that RSNetworking has but it was written to work with Swift 2.  RSNetworking and RSNetworking 2 are network libraries written entirely in the Swift programming language.  You can find RSNetworking 2 here:  https://github.com/hoffmanjon/RSNetworking2

Below lists the API that is exposed with RSNetworking 2

Classes
This section lists the classes that make up the RSNetworking API

RSTransaction
RSTransaction is the class that defines the transaction we wish to make. It exposes four properties, one initiator and one method.

Properties
  •   TransactionType - This defines the HTTP request method. Currently there are three types, GET, POST, UNKNOWN. Only the GET and POST actually sends a request. 
  •   baseURL - This is the base URL to use for the request. This will normally look something like this: "https://itunes.apple.com". If you are going to a non-standard port you would put that here as well. It will look something like this: "http://mytestserver:8080" 
  •   path - The path that will be added to the base url. This will normally be something like this: "search". It can also include a longer path string like: "path/to/my/service" 
  •   parameters - Any parameters to send to the service.

Initiators
  •   init(transactionType: RSTransactionType, baseURL: String, path: String, parameters: [String: String]) - This will initialize the RSTransaction with all properties needed.

Functions
  •   getFullURLString() -> String - Builds and returns the full URL needed to connect to the service.

RSTransactionRequest
RSTransactionRequest is the class that builds and sends out the request to the service defined by the RSTransaction. It exposes four functions.

Functions
  •   dataFromRSTransaction(transaction: RSTransaction, completionHandler handler: RSNetworking.dataFromRSTransactionCompletionCompletionClosure): Retrieves an NSData object from the service defined by the RSTransaction. This is the main function and is used by the other three functions to retrieve an NSData object prior to converting it to the required format.
  •   stringFromRSTransaction(transaction: RSTransaction, completionHandler handler: RSNetworking.stringFromRSTransactionCompletionCompletionClosure): Retrieves an NSString object from the service defined by the RSTransaction. This function uses the dataFromRSTransaction function to retrieve an NSData object and then converts it to an NSString object.
  •   dictionaryFromRSTransaction(transaction: RSTransaction, completionHandler handler: RSNetworking.dictionaryFromRSTransactionCompletionCompletionClosure): Retrieves an NSDictionary object from the service defined by the RSTransaction. This function uses the dataFromRSTransaction function to retrieve an NSData object and then converts it to an NSDictionary object. The data returned from the URL should be in JSON format for this function to work properly.
  •   imageFromRSTransaction(transaction: RSTransaction, completionHandler handler: RSNetworking.imageFromRSTransactionCompletionCompletionClosure): Retrieves an UIImage object from the service defined by the RSTransaction. This function uses the dataFromRSTransaction function to retrieve an NSData object and then converts it to an UIImage object.

RSURLRequest
RSURLRequest will send a GET request to a service with just a URL. There is no need to define a RSTransaction to use this class. RSURLRequest exposes four functions.

Functions
  •   dataFromURL(url: NSURL, completionHandler handler: RSNetworking.dataFromURLCompletionClosure): Retrieves an NSData object from the URL passed in. This is the main function and is used by the other three functions to retrieve an NSData object prior to converting it to the required format
  •   stringFromURL(url: NSURL, completionHandler handler: RSNetworking.stringFromURLCompletionClosure): Retrieves an NSString object from the URL passed in. This function uses the dataFromURL function to retrieve an NSData object and then converts it to an NSString object.
  •   dictionaryFromJsonURL(url: NSURL, completionHandler handler: RSNetworking.dictionaryFromURLCompletionClosure): Retrieves an NSDictionary object from the URL passed in. This function uses the dataFromURL function to retrieve an NSData object and then converts it to an NSDictionary object. The data returned from the URL should be in JSON format for this function to work properly.
  •   imageFromURL(url: NSURL, completionHandler handler: RSNetworking.imageFromURLCompletionClosure): Retrieves an UIImage object from the URL. This function uses the dataFromURL function to retrieve an NSData object and then converts it to an UIImage object.

RSUtilities
RSUtilities will contain various utilities that do not have their own class. Currently there is only one function exposed by this class

Functions
  •   isNetworkAvailable(hostname: NSString) -> Bool - This function will check to see if the network is available. This is a class function.
  •   networkConnectionType(hostname: NSString) -> ConnectionType - This function will return the type of network connection that is available. The ConnectionType is an enum which can equal one of the following three types: NONETWORK, MOBILE3GNETWORK or WIFINETWORK.

Extensions
This section lists the extensions that RSNetworking adds to the Swift language

UIImageView
  •     setImageForURL(url: NSString, placeHolder: UIImage): Sets the image in the UIImageView to the placeHolder image and then asynchronously downloads the image from the URL. Once the image downloads it will replace the placeholder image with the downloaded image.
  •     setImageForURL(url: NSString): Asynchronously downloads the image from the URL. Once the image is downloaded, it sets the image of the UIImageView to the downloaded image.
  •     setImageForRSTransaction(transaction:RSTransaction, placeHolder: UIImage): Sets the image in the UIImageView to the placeHolder image and then asynchronously downloads the image from the RSTransaction. Once the image downloads it will replace the placeholder image with the downloaded image.
  •     setImageForRSTransaction(transaction:RSTransaction): Asynchronously downloads the image from the RSTransaction. Once the image downloads it sets the image of the UIImageView to the downloaded image.
UIButton  
  •     setButtonImageForURL(url: NSString, placeHolder: UIImage, state: UIControlState): Sets the background image of the UIButton to the placeholder image and then asynchronously downloads the image from the URL. Once the image downloads it will replace the placeHolder image with the downloaded image.
  •     setButtonImageForURL(url: NSString, state: UIControlState): Asynchronously downloads the image from the URL. Once the download is complete, it will set the background image of the UIButton to the downloaded image.
  •     setButtonImageForRSTransaction(transaction:RSTransaction, placeHolder: UIImage, state: UIControlState): Sets the background image of the UIButton to the placeHolder image and then asynchronously downloads the image from the URL. Once the image downloads it will replace the placeHolder image with the downloaded image.
  •     setButtonImageForRSTransaction(transaction:RSTransaction, state: UIControlState): Asynchronously downloads the image from the URL. Once the download is complete, it will set the background image of the UIButton to the downloaded image.

Sample Code
This section contains sample code that show how to use RSNetworking

RSURLRequest
dataFromURL
let client = RSURLRequest()

if let testURL = NSURL(string:"https://itunes.apple.com/search?term=jimmy+buffett&media=music") {

   client.dataFromURL(testURL, completionHandler: {(response : NSURLResponse!, responseData: NSData!, error: NSError!) -> Void in
      if let error = error {
          print("Error : \(error)")
      } else {
          let string = NSString(data: responseData, encoding: NSUTF8StringEncoding)
          print("Response Data: \(string)")
      }
   }) 
}

dictionaryFromJsonURL
let client = RSURLRequest()

if let testURL = NSURL(string:"https://itunes.apple.com/search?term=jimmy+buffett&media=music") {

  client.dictionaryFromJsonURL(testURL, completionHandler: {(response : NSURLResponse!, responseDictionary: NSDictionary!, error: NSError!) -> Void in
      if let error = error {
          print("Error : \(error)")
      } else {
          print("Response Dictionary: \(responseDictionary)")
      }
   })
}

stringFromURL
let client = RSURLRequest()

if let testURL = NSURL(string:"https://itunes.apple.com/search?term=jimmy+buffett&media=music") {

  client.stringFromURL(testURL, completionHandler: {(response : NSURLResponse!, responseString: NSString!, error: NSError!) -> Void in
      if let error = error {
          print("Error : \(error)")
      } else {
          print("Response Data: \(responseString)")
      }
   })
}

imageFromURL
let client = RSURLRequest()

if let imageURL = NSURL(string:"http://a1.mzstatic.com/us/r30/Music/y2003/m12/d17/h16/s05.whogqrwc.100x100-75.jpg") {

  client.imageFromURL(imageURL, completionHandler: {(response : NSURLResponse!, image: UIImage!, error: NSError!) -> Void in
      if let error = error {
          print("Error : \(error)")
      } else {
          self.imageView?.image = image;
      }
   })
}

RSUtilities
RSUtilities.isHostnameReachable
  if (RSUtilities.isNetworkAvailable("www.apple.com")) {
     print("reachable")
 } else {
     print("Not Reachable")
 }

UIImageView: setImageForURL
let imageURL = "http://a1.mzstatic.com/us/r30/Music/y2003/m12/d17/h16/s05.whogqrwc.100x100-75.jpg"
  
imageView.setImageForURL(imageURL, placeHolder: UIImage(named: "loading"))    

  or

let imageURL = "http://a1.mzstatic.com/us/r30/Music/y2003/m12/d17/h16/s05.whogqrwc.100x100-75.jpg"

self.imageView?.setImageForURL(imageURL)

UIButton: setImageForURL
let imageURL = "http://a1.mzstatic.com/us/r30/Music/y2003/m12/d17/h16/s05.whogqrwc.100x100-75.jpg"

button.setButtonImageForURL(url, placeHolder: UIImage(named: "loading"), state:.Normal)

  or

let imageURL = "http://a1.mzstatic.com/us/r30/Music/y2003/m12/d17/h16/s05.whogqrwc.100x100-75.jpg"

button.setButtonImageForURL(url, state:.Normal)

RSTransactionRequest
RSTransactionRequest is designed to be used when you need to create mulitple requests to the same service. It allows you to set up the request once and then just change the parameters for each request

dictionaryFromRSTransaction
let rsRequest = RSTransactionRequest()

//Create the initial request
let rsTransGet = RSTransaction(transactionType: RSTransactionType.GET, baseURL: "https://itunes.apple.com", path: "search", parameters: ["term":"jimmy+buffett","media":"music"])

rsRequest.dictionaryFromRSTransaction(rsTransGet, completionHandler: {(response : NSURLResponse!, responseDictionary: NSDictionary!, error: NSError!) -> Void in
    if let error = error {
        print("Error : \(error)")
    } else {
        print(responseDictionary)
    }
})


Now that you have the RSTransaction, you can simply change the parameters and make another request, if needed, like this:
  
let rsRequest = RSTransactionRequest()

//Create the initial request
rsTransGet.parameters = ["term":"Jimmy", "media":"music"]

rsRequest.dictionaryFromRSTransaction(rsTransGet, completionHandler: {(response : NSURLResponse!, responseDictionary: NSDictionary!, error: NSError!) -> Void in
    if let error = error {
        print("Error : \(error)")
    } else {
        print(responseDictionary)
    }
})

stringFromRSTransaction
  
//Change parameters from the previously example so we can make a second request
rsTransGet.parameters = ["term":"Jimmy", "media":"music"]
rsRequest.stringFromRSTransaction(rsTransGet, completionHandler: {(response : NSURLResponse!, responseString: NSString!, error: NSError!) -> Void in
    if let error = error {
        print("Error : \(error)")
    } else {
        print(responseString)
    }
})


If there is a feature that you would like to see in RSNetworking 2, please leave a comment to this blog post or in the github site here:  https://github.com/hoffmanjon/RSNetworking2.  If you would like to contribute to RSNetworking 2, please feel free to do so. 

Saturday, July 26, 2014

RSNetworking – Major Update

I recently wrote an iOS communication library for the SparkCore in Objective-C and it gave me some great ideas on how the RSNetworking library could work.  I have updated the RSNetworking library to include my ideas and will be depreciating the original RSNetworking class soon.  After trying the new library out with the sample project, I am really excited about the update.  Please let me know what you think of the changes and any ideas that you may have.  You can find the code, with a sample application on GitHub here:  https://github.com/hoffmanjon/RSNetworking

While the original RSNetworking class is still in the library, I have put notes in the class that it will be going away soon.  Instead I moved the dataFromURL, stringFromURL, dictionaryFromURL, and imageFromURL functions to the new RSURLRequest class.  You can use these functions exactly like you used them before.  Eventually I would like to make these functions class (static) functions but it does not appear that the class (static) functionally is fully implemented yet (as of beta 4) since I cannot define class variables yet.

The isHostnameReachable function has moved to the RSUtilities class.  The RSUtilities class will contain various utilities.  Currently the isHostnameReachable function is the only function defined in the RSUtilities class.

Now we come to the big changes in the library.  These changes are part of two classes.  These are the RSTransaction and RSTransactionRequest classes.  Lets look at how we would use them to submit a GET request to Apple’s iTunes search API:

//initilate the RSTransactionRequest()
        var rsRequest = RSTransactionRequest()
       
//Define a RSTranaction object
        var rsTransGet = RSTransaction(transactionType: RSTransactionType.GET, baseURL: "https://itunes.apple.com", path: "search", parameters: ["term":"jimmy+buffett","media":"music"])
       
   
//Call the dictionaryFromRSTransaction function to make the request to the iTunes search API using the RSTransaction we created
        rsRequest.dictionaryFromRSTransaction(rsTransGet, completionHandler: {(response : NSURLResponse!, responseDictionary: NSDictionary!, error: NSError!) -> Void in
            if !error? {
                     println(responseDictionary)
            } else {
                //If there was an error, log it
                println("Error : \(error)")
            }
            })

We begin by initializing a RSTransactionRequest object.  Eventually I would like to make the functions in RSTransactionRequest class (static) functions but, like I noted above, the class (static) functionality does not look complete yet. 

Once we have the RSTransactionRequest object, we then create an RSTransaction object using the init(transactionType: RSTransactionType, baseURL: String,  path: String, parameters: [String: String]) initializer.  The RSTransaction class is designed to contain everything needed to create a request to a HTTP web service.  We then use the dictionaryFromRSTransaction function from the RSTransactionRequest object, passing in the RSTransaction object, to make the web service call.

What makes this so nice is we can now simply update the parameters of the RSTransaction class like this:

rsTransGet.parameters = ["term":"jimmy","media":"music"]

Then we can resubmit the RSTransaction to make another call. This will allow use to have numerous web services configured but we will only need one instance of the RSTransactionRequest class.  This will really become evident when we can make the functions in the RSTransactionRequest class, class (static) functions.

Lets take a look at how we would submit a POST request using the posttestserver.com site.  To make this request we use the same RSTransactionRequest object (rsRequest) that we used to make the GET request to Apple’s iTunes search API.  Here is the code:

//Post request
var rsTransPost = RSTransaction(transactionType: RSTransactionType.POST, baseURL: "https://posttestserver.com", path: "post.php", parameters: ["key":"value","key2":"value2"])
       
//Call the stringFromRSTrasaction function to make the request to posttestserver.com
rsRequest.stringFromRSTransaction(rsTransPost, completionHandler: {(response : NSURLResponse!, responseString: NSString!, error: NSError!) -> Void in
        if !error? {
            //Log response string
            println(responseString)
        } else {
            //If there was an error, log it
            println("Error : \(error)")
        }
       })
As you can see, the POST requests is exactly like the GET requests except we changed the transactionType parameter to RSTransactionType.POST instead of RSTransactionType.GET.

The RSTransaction class exposes four properties, one initiator and one method.  These are:
- Properties
* TransactionType - This defines the HTTP request method.  Currently there are three types, GET, POST, UNKNOWN.  Only the GET and POST actually sends a request.
* baseURL - This is the base URL to use for the request.  This will normally look something like this:  "https://itunes.apple.com".  If you are going to a non-standard port you would put that here as well.  It would look something like this:  "http://mytestserver:8080"
*path - The path that will be added to the base url.  This will normally be something like this: "search".  It can also include a longer path string like: "path/to/my/service"
* parameters - Any parameters to send to the service.
- Initiators
* init(transactionType: RSTransactionType, baseURL: String,  path: String, parameters: [String: String]) - This will initialize the RSTransaction with all properties needed.
- Function
* getFullURLString() -> String - Builds and returns the full URL needed to connect to the service.

The RSTransactionRequest contains exposes four functions.  These are:
* dataFromRSTransaction(transaction: RSTransaction, completionHandler handler: RSNetworking.dataFromRSTransactionCompletionCompletionClosure):
 Retrieves an NSData object from the service defined by the RSTransaction.  This is the main function and is used by the other three functions to retrieve an NSData object prior to converting it to the required format.

* stringFromRSTransaction(transaction: RSTransaction, completionHandler handler:  RSNetworking.stringFromRSTransactionCompletionCompletionClosure):  
Retrieves an NSString object from the service defined by the RSTransaction.  This function uses the dataFromRSTransaction function to retrieve an NSData object and then converts it to an NSString object.

*dictionaryFromRSTransaction(transaction: RSTransaction, completionHandler handler:  RSNetworking.dictionaryFromRSTransactionCompletionCompletionClosure):
 Retrieves an NSDictionary object from the service defined by the RSTransaction.  This function uses the dataFromRSTransaction function to retrieve an NSData object and then converts it to an NSDictionary object.  The data returned from the URL should be in JSON format for this function to work properly.

*imageFromRSTransaction(transaction: RSTransaction, completionHandler handler:  RSNetworking.imageFromRSTransactionCompletionCompletionClosure):
Retrieves an UIImage object from the service defined by the RSTransaction.  This function uses the dataFromRSTransaction function to retrieve an NSData object and then converts it to an UIImage object.

Hopefully others will find this library useful.  To receive notifications when the RSNetworking library is updated, please subscribe to my twitter feed.  You can download the code from GitHub here:  https://github.com/hoffmanjon/RSNetworking