Mac Developers blog

To make sure that the drivers are installed, type in the Terminal:

ls /dev/tty.*

Next we have to find our device. Here's what our device looks like:

/dev/tty.PL2303-00001014

Connect contacts. Rx/Tx voltage of UART signals is 3.3V, which permits to connect contacts to the board directly. 5V power supply is provided by UART as well. Thus, we are using all the UART contacts: Rx/Tx, +5V and GND.

Sim900 module by default requires 115200 bit/s connection speed, 8 bits per symbol and 1 stop bit. All other options should be disabled.

UART is rather simple serial interface, even simpler than Serial Com port, but we can use the same components for work with it, limited only by the data exchange on the specified transfer speed.

OS X lets us work with serial port via tеrmios, which is the part of POSIX. All we have to do is tune port settings and try to transfer data.

For data exchange we'll use Swift programming language. Here's how setting port options looks like:

func openWithDevicePath(devicePath:String, error:NSErrorPointer?) -> Bool { let d : Int32 = open(devicePath, O_RDWR | O_NOCTTY | O_NDELAY) if d == -1 { if let err = error { err.memory = NSError(domain: "could not open device", code: -1, userInfo: nil) } return false } var tty = UnsafeMutablePointer.alloc(1) if tcgetattr(d, tty) != 0 { close(d) if let err = error { err.memory = NSError(domain: "tcgetattr failed", code: -1, userInfo: nil) } return false } if cfsetospeed (tty, 115200) == -1 { close(d) if let err = error { err.memory = NSError(domain: "cfsetospeed failed", code: -1, userInfo: nil) } return false } if cfsetispeed (tty, 115200) == -1 { close(d) if let err = error { err.memory = NSError(domain: "cfsetispeed failed", code: -1, userInfo: nil) } return false } tty.memory.c_cflag = (tty.memory.c_cflag & ~UInt(CSIZE)) | UInt(CS8); // 8-bit chars tty.memory.c_iflag = ~UInt(IGNBRK) // ignore break processing tty.memory.c_lflag = 0 // no signaling chars, no echo, tty.memory.c_oflag = 0 // no remapping, no delays tty.memory.c_iflag &= ~(UInt(IXON) | UInt(IXOFF) | UInt(IXANY)) // shut off xon/xoff ctrl tty.memory.c_cflag |= (UInt(CLOCAL) | UInt(CREAD)) // ignore modem controls, tty.memory.c_cflag &= ~(UInt(PARENB) | UInt(PARODD)) // shut off parity tty.memory.c_cflag |= 0 tty.memory.c_cflag &= ~UInt(CSTOPB) // One stop bit tty.memory.c_cflag &= ~((UInt(CCTS_OFLOW) | UInt(CRTS_IFLOW))) // Disable RTS/CTS if tcsetattr (d, TCSANOW, tty) != 0 { close(d) if let err = error { err.memory = NSError(domain: "cfsetispeed failed", code: -1, userInfo: nil) } return false } sim900descriptor = d return true }

The function should be always called before starting work with Sim900. The data is sent and received via read and write functions, that's why the command execution will be realized via timer. Receiving data from the device is similar to the work of Terminal. In the next posts we'll give a closer examination of Pooling mode, where the data is received.

So let's execute a simple command to test connection to the module - “AT”. main function in Swift looks like:

var error : NSError? let sim900descriptor = sim900DescriptorWithDevicePath("/dev/tty.PL2303-00001014", &error) if sim900descriptor == -1 { if let e = error { println("Error: \(e.localizedDescription)") } exit(1) } let cmd = "AT\r\n" write(sim900descriptor, cmd, UInt(countElements(cmd))) sleep(2) var buffer = UnsafeMutablePointer.alloc(Int(128)) memset(buffer, 0, 128) let bitesReaded = read(sim900descriptor, buffer, 127) if let response = String.fromCString(buffer) { println("Response: \(response)") }

Data is transferred via write call, as you've probably noticed. If OK is returned, data transfer settings are correct. Here's a sample which allows sending an SMS message and making an outgoing call. Let's describe two simple commands.

We are going to dial a telephone number, so we need to pass a command in “ATD;” format, which has the following look:

func dialNumber(phoneNumber:String) { let dialCmd = "ATD\(phoneNumber);\r\n" write(sim900descriptor, dialCmd, UInt(countElements(dialCmd))) }

Making a call is that easy. Sending an SMS message is a little harder and may remind you sending POST request to the Internet. Once the command is received, the module will wait for the body of the letter and 1A symbol.

To do this, we'll use command of “AT+CMGS=” format. Once it is sent, send the body of the message with 0x1A symbol in the end, in case the module didn't return an error.

Look, that's dead simple:

func sendMessage(message:String, toNumber:String) { let smsCmd = "AT+CMGS=\"\(toNumber)\"\r\n" write(sim900descriptor, smsCmd, UInt(countElements(smsCmd))) sleep(1); write(sim900descriptor, message, UInt(countElements(message))) write (sim900descriptor, UnsafePointer([0x1A] as Array), 1); }

We use read function to get all the data during application work:

func availableData() -> String? { var buffer = UnsafeMutablePointer.alloc(Int(128)) memset(buffer, 0, 128) let bitesReaded = read(sim900descriptor, buffer, 127) if bitesReaded > 0 { return String.fromCString(buffer) } return nil }

You can download xcode project of the test application from this post here: sim900_practice.zip

Subscribe here:

Adding Classes to the Project

SharedPoint class

Create a new Swift class named SharedPoint. To do this, choose from the menu: File > New > File > OS X > Source > Swift. This class is designed to describe the compliance between file sharing service and its IP address.

SharedPoint.swift file contains a string with import statement:

import Foundation

This string is intended to import Objective-C Foundation system framework into the Swift project. Importing makes all API of the framework available in Swift.

Add the SharedPoint class definition to the file. Class definition starts with the key word class and is enclosed in curly brackets:

class SharedPoint { // class definition goes here }

Add three properties to the class:

netService – variable of NSNetService type – file sharing service on computer.

type – variable of String type – file sharing protocol (SMB or AFP).

ipAddress – variable of String type - computer's IP address in the network.

class SharedPoint { var netService:NSNetService var type:String var ipAddress:String }

If app is launched right away, the following compilation error is invoked:

Class ‘SharedPoint’ has no initializers.

This happens because Swift requires all class properties, the types of which are optional, to be initialized at class instantiation.

Add initializer with three named parameters to the class:

init(netService:NSNetService, type:String, ipAddress:String) { self.netService = netService self.type = type self.ipAddress = ipAddress }

With this initializer you can create an instance of the SharedPoint class, passing named values to each of its parameters. Note that one cannot call the initializer without stating external parameters names as it will lead to error.

Add the Equatable protocol conformance to the SharedPoint class. It allows to define whether two values of one and the same type are identical. To do this, add the name of Equatable protocol to the SharedPoint class definition after the class name separated by a colon:

class SharedPoint:Equatable { // class definition goes here }

Then add the following function at global scope:

func == (lhs: SharedPoint, rhs: SharedPoint) -> Bool { return (lhs.netService == rhs.netService) && (lhs.type == rhs.type) && (lhs.ipAddress == rhs.ipAddress) }

SharedBrowser class

Create a new Swift class named SharedBrowser. The class is intended to search computers with enabled file sharing in the network. To implement the search option, we'll use NSNetServiceBrowser class, which defines an interface for finding published services on a network using multicast DNS. Due to the possible delays associated with network traffic, NSNetServiceBrowser objects perform browsing asynchronously by registering with the default run loop. Browsing results are returned to your app through delegate methods. To handle results from an NSNetServiceBrowser object, you must assign it a delegate.

Thus, to perform search, do the following:

Initialize an NSNetServiceBrowser instance and assign a delegate to the object.

Start the search.

Handle search results and other messages sent to delegate.

Each browser service performs one search operation at a time, so to perform multiple operations simultaneously, use several browser services. We'll need two browser services: the first one - to search the network for computers which use SMB protocol for files sharing, the second one - to search the network for computers which use AFP protocol.

From the NSNetServiceBrowserDelegate protocol declaration, we see that it requires a conforming type also to conform to the NSObjectProtocol protocol:

protocol NSNetServiceBrowserDelegate : NSObjectProtocol { // protocol definition goes here }

Since NSObject class conforms to the NSObjectProtocol protocol:

class NSObject : NSObjectProtocol { // class definition goes here }

we'll make it superclass for the SharedBrowser class:

class SharedBrowser:NSObject { // class definition goes here }

Add the following properties to SharedBrowser class:

afpType - constant of String type - registration name of AFP service, which works over TCP protocol (see Bonjour Names for Existing Service Types);

smbType - constant of String type - registration name of SMB service;

smbBrowser - constant of NSNetServiceBrowser type - browser for computers in the network that provide access to files and folders over SMB protocol;

afpBrowser - variable of NSNetServiceBrowser type - browser for computers in the network that provide access to files and folders over AFP protocol;

serviceList - the list of detected services (array of objects of NSNetService type);

sharedPointsList - array of objects of SharedPoint type, each of which can be used for connecting to a certain computer in the network with enabled sharing via the IP address over the supported sharing protocol.

class SharedBrowser:NSObject { let afpType:String let smbType:String var smbBrowser:NSNetServiceBrowser var afpBrowser:NSNetServiceBrowser var serviceList:[NSNetService] var sharedPointsList:[SharedPoint] }

To add initializer init() to SharedBrowser class, it's necessary to override the designated NSObject initializer of its superclass via the key word override.

override init() { self.afpType = "_afpovertcp._tcp." self.smbType = "_smb._tcp." self.smbBrowser = NSNetServiceBrowser() self.afpBrowser = NSNetServiceBrowser() self.serviceList = [NSNetService]() self.sharedPointsList = [SharedPoint]() super.init() self.afpBrowser.delegate = self self.smbBrowser.delegate = self }

Initializer first assigns values to class properties, then it delegates up to init() initializer of the NSObject class. Then the fully initialized object assigns itself as delegate for objects afpBrowser and smbBrowser.

Please pay attention that calling the superclass’s initializer init() precedes the setting of delegates. Otherwise we'll get the compilation error:

'self' used before super.init call.

Delegate of the NSNetServiceBrowser object must conform to the NSNetServiceBrowserDelegate protocol. To avoid the following compilation error:

Type ‘SharedBrowser’ does not conform to protocol ’NSNetServiceBrowserDelegate’,

add the name of the NSNetServiceBrowserDelegate protocol to the SharedBrowser class header after the name of its superclass, separated by comma:

class SharedBrowser:NSObject, NSNetServiceBrowserDelegate { //properties and methods }

The NSNetServiceBrowserDelegate protocol defines the optional methods implemented by delegates of NSNetServiceBrowser objects.

Let's study some of them:

netServiceBrowser(_,didFindService:,moreComing:) tells the delegate the browser found a service.

Method declaration:

optional func netServiceBrowser(_ netServiceBrowser: NSNetServiceBrowser, didFindService netService: NSNetService, moreComing moreServicesComing: Bool)

netService parameter of NSNetService type is the detected service.

moreServicesComing parameter of Bool type shows whether the browser expects any other additional services.

Add implementation of this method to SharedBrowser class. When calling this method, the detected service is to be added to serviceList array, and when the service search is over, update() method, which description is provided below, is to be called:

func netServiceBrowser(aNetServiceBrowser: NSNetServiceBrowser, didFindService aNetService: NSNetService, moreComing: Bool) { serviceList.append(aNetService) NSLog("Found: \(aNetService)") if !moreComing { update() } }

netServiceBrowser(_,didRemoveService:,moreComing:) method tells the delegate a service has disappeared or has become unavailable.

Method declaration:

optional func netServiceBrowser(_ netServiceBrowser: NSNetServiceBrowser, didRemoveService netService: NSNetService, moreComing moreServicesComing: Bool)

When calling this method, the service which became unavailable is to be deleted from serviceList array, and its corresponding elements should be deleted from sharedPointsList array. When the service search is over, update() method should be called.

func netServiceBrowser(aNetServiceBrowser: NSNetServiceBrowser, didRemoveService aNetService: NSNetService, moreComing: Bool) { let iService = find(serviceList, aNetService) if iService != nil { serviceList.removeAtIndex(iService!) } let subArray = sharedPointsList.filter({$0.netService == aNetService}) for item in subArray { let iSharedPoint = find(sharedPointsList, item) if iSharedPoint != nil { sharedPointsList.removeAtIndex(iSharedPoint!) } } NSLog("Became unavailable: \(aNetService)") if !moreComing { update() } }

find method returns the first index where `value` appears in `domain` or `nil` if `value` is not found. Elements must conform to the Equatable protocol.

filter method returns an array containing the elements of the receiver for which a provided closure indicates a match. In our case it's an array of elements of [SharedPoint] type, in which netService variable refers to the service which became unavailable.

netServiceBrowser(_,didNotSearch:) method tells the delegate that the search failed.

Method declaration:

optional func netServiceBrowser(_ netServiceBrowser: NSNetServiceBrowser, didNotSearch errorDict: [NSObject : AnyObject])

When calling this method, the message containing the error code will be displayed in console. One can get the error code via the NSNetServiceErrorCode key in errorDict dictionary.

func netServiceBrowser(aNetServiceBrowser: NSNetServiceBrowser, didNotSearch errorDict: [NSObject : AnyObject]) { NSLog("Search was not successful. Error code: \(errorDict[NSNetServicesErrorCode]!)") }

In update() method, for each service of serviceList array, we'll set object of SharedBrowser class as delegate, and start the process of service address resolution.

func update() { for service in serviceList { service.delegate = self service.resolveWithTimeout(5) } }

NSNetService object delegate must conform to the NSNetServiceDelegate protocol. The name of the NSNetServiceDelegate protocol should be added to the SharedBrowser class header.

class SharedBrowser:NSObject, NSNetServiceBrowserDelegate, NSNetServiceDelegate { //properties and methods }

The NSNetServiceDelegate protocol defines the optional methods implemented by delegates of the NSNetService objects.

We'll add this protocol conformance to the SharedBrowser class.

netServiceDidResolveAddress(_) method informs the delegate that the address for a given service was resolved.

optional func netServiceDidResolveAddress(_ sender: NSNetService)

Let's study in detail the method implementation:

func netServiceDidResolveAddress(sender: NSNetService) { for addressBytes in sender.addresses! { var inetAddress : sockaddr_in! var inetAddress6 : sockaddr_in6! //NSData’s bytes returns a read-only pointer to the receiver’s contents. var inetAddressPointer = UnsafePointer(addressBytes.bytes) //Access the underlying raw memory inetAddress = inetAddressPointer.memory if inetAddress.sin_family == __uint8_t(AF_INET) { } else { if inetAddress.sin_family == __uint8_t(AF_INET6) { var inetAddressPointer6 = UnsafePointer(addressBytes.bytes) inetAddress6 = inetAddressPointer6.memory inetAddress = nil } else { inetAddress = nil } } var ipString : UnsafePointer? //static func alloc(num: Int) -> UnsafeMutablePointer var ipStringBuffer = UnsafeMutablePointer.alloc(Int(INET6_ADDRSTRLEN)) if inetAddress != nil { var addr = inetAddress.sin_addr ipString = inet_ntop(Int32(inetAddress.sin_family), &addr, ipStringBuffer, __uint32_t (INET6_ADDRSTRLEN)) } else { if inetAddress6 != nil { var addr = inetAddress6.sin6_addr ipString = inet_ntop(Int32(inetAddress6.sin6_family), &addr, ipStringBuffer, __uint32_t(INET6_ADDRSTRLEN)) } } if ipString != nil { // Returns `nil` if the `CString` is `NULL` or if it contains ill-formed // UTF-8 code unit sequences. var ip = String.fromCString(ipString) if ip != nil { NSLog("\(sender.name)(\(sender.type)) - \(ip!)") var ext : String switch sender.type { case afpType : ext = "afp" case smbType : ext = "smb" default: ext = sender.type } sharedPointsList.append(SharedPoint(netService:sender, type:ext, ipAddress:ip!)) NSNotificationCenter.defaultCenter().postNotificationName( "NewSharedDetected", object: self) } } ipStringBuffer.dealloc(Int(INET6_ADDRSTRLEN)) } }

addresses property of NSNetService class returns an array of objects of [AnyObject] type, each of which contains the sockaddr structure, which can be used to connect to socket:

var addresses: [AnyObject]? { get }

When working with Cocoa APIs, it is common to receive an array with a type of [AnyObject], or “an array of values of any object type”. This is because Objective-C does not have explicitly typed arrays. Though, in the most of cases you can be sure of the type of objects contained in such an array, basing on the information about the API provided by the array.

For example, in our case it is known that the type of objects in array returned by addresses property of NSNetService class is NSData.

Enumerate all elements of sender.addresses array (sender constant of NSNetService type is a service for which addresses are resolved) and perform the following:

1. Declare two variables: inetAddress of sockaddr_in! type and inetAddress6 of sockaddr_in6! type for IPv4 and IPv6 addresses correspondingly. Both variables are implicitly unwrapped optionals.

sockaddr_in structure describes the socket for work with TCP/IP protocols and has the following form:

struct sockaddr_in { var sin_len: __uint8_t var sin_family: sa_family_t var sin_port: in_port_t var sin_addr: in_addr var sin_zero: (Int8, Int8, Int8, Int8, Int8, Int8, Int8, Int8) }

The structure properties:

sin_len - structure length;

sin_family - address family (must be equal to AF_INET);

sin_port - port of IP addresses;

sin_addr - IP address;

sin_zero - padding.

For IPv6 address representation, sockaddr_in6 structure is used. sin6_family property stores address family (must be equal to AF_INET6), and sin6_addr property stores IPv6 address.

2. Declare inetAddressPointer variable and assign constant pointer to sockaddr_in structure to it. bytes property of NSData class returns pointer of UnsafePointer<()> type (analog in Objective-C is const void *) to data of object of this class:

var bytes: UnsafePointer<()> { get }

As it is known that the object contains sockaddr structure, we can cast returned value to UnsafePointer type.

3. Assign to inetAddress variable the value which is stored in inetAddressPointer pointer.

To get the object stored in UnsafePointer structure, we'll use its memory property:

var memory: T { get }

4. Check address family. Note that during address family check implicit type casting is carried out (AF_INET – Int32 type, while the type of sin_family property of sockaddr_in structure is sa_family_t (alias for __uint8_t type). Omitting type casting leads to compilation error.

In case the address family is AF_INET (IPv4 address), no additional actions are required. Otherwise, check whether AF_INET6 (IPv6) is the address family. If it really is, then assign constant pointer to sockaddr_in6 structure to inetAddressPointer6 variable, the structure stored in this address to inetAddress6 variable, and nil to inetAddress variable.If not, assign nil to inetAddress variable.

5. Declare ipString variable of UnsafePointer? optional type. Question mark means that the variable value is optional, that is, the variable can contain constant pointer to Int8 type or can contain no values at all.

6. Declare ipStringBuffer variable of UnsafeMutablePointer type (pointer to Int8 type) and allocate memory via alloc method.

7. As there is a possibility that inetAddress variable became equal to nil, process it as optional variable to check whether it contains any value. If it does, declare addr variable and assign to it the address stored in sin_addr field of inetAddress structure. Then assign constant pointer to the string returned by inet_ntop function to ipString variable.

inet_ntop function converts a packed Internet address into the readable format. The function gets binary IP address and returns the pointer to the string which contains decimal format with dots and colons.

inet_ntop function declaration in Swift:

func inet_ntop(_: Int32, _: UnsafePointer, _: UnsafeMutablePointer, _: socklen_t) -> UnsafePointer

Function parameters:

variable of Int32 type - address family (sin_family variable of inetAddress structure should be casted to Int32 type, that is Int32(inetAddress.sin_family));

constant pointer of UnsafePointer type. Here’s an extract from Apple's doc "Using Swift with Cocoa and Objective-C. Interacting with C APIs":

When a function is declared as taking a UnsafePointer argument, it can accept the same operands as UnsafePointer for any type Type.

That's why, we can pass the value of UnsafePointer type to the function as the second argument, that is, constant pointer to in_addr structure which stores IP address.

variable of UnsafeMutablePointer type - pointer to buffer;

variable of socklen_t type - buffer size (cast INET6_ADDRSTRLEN constant of Int32 type to __uint32_t type (socklen_t type is alias for __uint32_t)).

Underscore (_) means that you don't have to indicate outer names for the parameters at function call.

In case inetAddress variable does not contain value, check whether inetAddress6 variable contains any value. If it does, declare addr variable and assign to it the address which is stored in sin6_addr field of inetAddress6 structure. Then assign constant pointer to the string returned by inet_ntop function to ipString variable.

8. Then check whether variable ipString contains value. If it does, declare ip variable and assign it the value returned by fromCString static method of String structure.

Since ipString variable is of UnsafePointer? optional type, one needs to force unpack it (exclamation mark after the variable name) before passing it to fromCString method. Casting UnsafePointer type to UnsafePointer type is not necessary, as CChar is alias for Int8.

If ip variable contains the value, declare ext variable of String type and assign to it the value depending on the service type. Note that in switch-case construction there is no break operator in case-blocks, as, unlike switches in C and Objective-C, switches in Swift do not pass to the next block by default after executing code inside the corresponding case-block.

Add to sharedPointsList array the object of SharedPoint class, which is created via initializer with three named parameters. As ip variable is of String? type, that is, optional String, we'll force unpack it.

After that, send to the notification center of the process the notification that a new point with file sharing was found.

9. Since UnsafePointer structure does not provide automatic memory control, free the memory allocated to ipStringBuffer variable.

Add implementation of one more method of the NSNetServiceDelegate protocol to the SharedBrowser class.

netServiceDidResolveAddress(_,didNotResolve:) method informs the delegate that an error occurred during resolution of a given service.

Method declaration:

optional func netService(_ sender: NSNetService, didNotResolve errorDict: [NSObject : AnyObject])

When calling this method, a message with code error will be shown in console. One can get an error code via NSNetServiceErrorCode key from errorDict dictionary.

func netService(sender: NSNetService, didNotResolve errorDict: [NSObject : AnyObject]) { NSLog("\(sender.name) did not resolve: \(errorDict[NSNetServicesErrorCode]!)") }

All is left is to add to the class SharedBrowser method which is intended to launch network search for computers with enabled file sharing. In our case, there are three search variants available:

search for computers with file sharing via AFP protocol;

search for computers with file sharing via SMB protocol;

search for computers with file sharing via AFP and SMB protocols.

To differentiate the three search variants, we'll create ServiceType enumeration with three members, each of which corresponds to the definite search variant:

enum ServiceType { case Afp case Smb case AfpAndSmb }

Note that, unlike in C and Objective-C, integer values cannot be assigned by default to enumeration members at their creation in Swift. Afp, Smb and AfpAndSmb members in ServiceType enumeration are not equal to 0, 1 and 2 correspondingly, but they are actual values.

Add the following method to SharedBrowser class:

func searchForServicesOfType(type:ServiceType) { switch type { case .Afp: afpBrowser.searchForServicesOfType(afpType, inDomain: "") case .Smb: smbBrowser.searchForServicesOfType(smbType, inDomain: "") case .AfpAndSmb: afpBrowser.searchForServicesOfType(afpType, inDomain: "") smbBrowser.searchForServicesOfType(smbType, inDomain: "") } }

The method accepts the only parameter of ServiceType type, describing the search variant. In switch-case construction, the short form of access to ServiceType enumeration members is used, like .Afp, not ServiceType.Afp, since it is known that the variable type is ServiceType.

searchForServicesOfType(_,inDomain:) method of NSNetServiceBrowser class launches the search for services of the definite type in the specified domain.

Method declaration:

func searchForServicesOfType(_ serviceType: String, inDomain domainName: String)

Passing an empty string to the method as the second parameter lets the browser search for services among registration domains used by default.

Add to SharedBrowser class the last method which is intended to stop the current search and clear its results:

func reset() { smbBrowser.stop() afpBrowser.stop() for service in serviceList { service.stop() } serviceList.removeAll() sharedPointsList.removeAll() }

Now let's start the creation of the user interface.

User Interface Creation

1. Choose MainMenu.xib file in project browser to display SharingBrowser window.

2. Display the Utilities in the right corner of the window. To do this, click the rightmost button of View switch on the toolbar.

3. Display the main window. To do this, click Window icon in Editor.

4. Open the Object Library. The Object Library can be found in the lower part of the Utilities.

5. Drag Push Button, Table View, two Check Boxes and Box to the window from the Object Library.

6. Place the objects as shown on the picture and name them appropriately.

7. In Attributes inspector tab, choose Content Mode in Cell Based, and set the number of Columns to 4.

8. For each column of the table set the name in Attributes inspector tab. In Identity inspector tab, set the Restoration ID: Name and name correspondingly for the 1rst column, Domain and domain - for the 2nd column, Type and type - for the 3rd column, IP and ip - for the 4th column.

9. Create outlet for each element in AppDelegate class. To do this, display Assistant editor panel by clicking Editor switch button

 on the toolbar. Make sure that Assistant editor displays AppDelegate.swift file. If not, choose AppDelegate.swift file from Top Level Objects menu in the upper part of the panel.

For each element, do the following:

Click Control key and hold it, while dragging element to AppDelegate.swift file;

Release Control key and Assistant editor will display connection setup window;

Choose Outlet from Connection menu;

Input the name and click Connect button.

Interface Builder will add the outlet declaration to the class. Outlets in Swift are declared via the @IBOutlet key word.

The following strings should appear in AppDelegate class:

@IBOutlet weak var window: NSWindow! @IBOutlet weak var sharedPointsTable: NSTableView! @IBOutlet weak var afpCheckBox: NSButton! @IBOutlet weak var smbCheckBox: NSButton! @IBOutlet weak var searchBtn: NSButton!

10. Set AppDelegate object as the data source for the table. To do this, click Control key and hold it, while dragging the pointer from the table towards AppDelegate object in the objects hierarchy. Choose dataSource property.

11. Add action for Search button. Click Control key and hold it, while dragging Search button into AppDelegate.swift file. Release Control key, choose Action from Connection menu, input searchBtnAction as the action name. Interface Builder will add the stub for the method to AppDelegate class:

@IBAction func searchBtnAction(sender: AnyObject) { }

Code Adding

Go to AppDelegate.swift file.

Add sharedBrowser property and initialize it by the instance of the SharedBrowser class:

let sharedBrowser = SharedBrowser()

Add the following code to the button click handler of Search button:

@IBAction func searchBtnAction(sender: AnyObject) { var searchType:ServiceType? if afpCheckBox.state == NSOnState { if smbCheckBox.state == NSOnState { searchType = .AfpAndSmb } else { searchType = .Afp } } else if smbCheckBox.state == NSOnState { searchType = .Smb } if searchType != nil { sharedBrowser.reset() sharedPointsTable.reloadData() sharedBrowser.searchForServicesOfType(searchType!); } else { var alert = NSAlert() alert.messageText = "Choose protocol!" alert.alertStyle = .WarningAlertStyle alert.runModal() } }

First, declare searchType variable of ServiceType? type, that is, optional ServiceType type. Make sure that afpCheckBox checkbox is ticked. If it is, make sure that smbCheckBox checkbox is ticked as well. If yes, assign .AfpAndSmb value to searchType, otherwise - .Afp.

If afpCheckBox checkbox is not ticked, make sure that smbCheckBox checkbox is ticked. If yes, assign .Smb value to searchType. Check whether searchType variable contains value. If it does, stop the previous search, clear its results and srart the new search. If not, display the warning window.

To populate the table with content programmatically, NSTableViewDataSource protocol should be realized. Since AppDelegate class was set in Interface Builder as the data source for the table, add the NSTableViewDataSource protocol conformance to it:

class AppDelegate: NSObject, NSApplicationDelegate, NSTableViewDataSource { // class definition goes here }

numberOfRowsInTableView(_:) method of NSTableViewDataSource protocol returns the number of records provided to NSTableView object by the data source.

Method declaration:

optional func numberOfRowsInTableView(_ aTableView: NSTableView) -> Int

Add this method implementation to the AppDelegate class:

func numberOfRowsInTableView(tableView: NSTableView!) -> Int { return sharedBrowser.sharedPointsList.count }

tableView(_:objectValueForTableColumn:row:) method of the NSTableViewDataSource protocol is called by the table to return the data of the object, related to the indicated row and column.

Method declaration:

optional func tableView(_ aTableView: NSTableView, objectValueForTableColumn aTableColumn: NSTableColumn?, row rowIndex: Int) -> a href="" AnyObject /a ?

Add this method implementation to the AppDelegate class:

func tableView(tableView: NSTableView, objectValueForTableColumn tableColumn: NSTableColumn?, row: Int) -> AnyObject? { if row < 0 || row >= sharedBrowser.sharedPointsList.count { return "" } if let columnId = tableColumn?.identifier { let sharedPoint = sharedBrowser.sharedPointsList[row] if columnId == "name" { return sharedPoint.netService.name } else if columnId == "domain" { return sharedPoint.netService.domain } else if columnId == "type" { return sharedPoint.type } else if columnId == "ip" { return sharedPoint.ipAddress } } return "" }

In applicationDidFinishLaunching(_:) method set the AppDelegate class itself as the target for the sharedPointsTable, and set the selector for its doubleAction property. At double-click on the table's row, mountToShare(sender:) method will be called, which is indented to create the connection to file sharing service, corresponding to the row. In this very method subscribe to NewSharedDetected notification, upon receipt of which reloadSharedPointsTable(), method will be called, which is indented to refresh sharedPointsTable table data.

func applicationDidFinishLaunching(aNotification: NSNotification) { // Insert code here to initialize your application sharedPointsTable.target = self sharedPointsTable.doubleAction = "mountToShare:" NSNotificationCenter.defaultCenter().addObserver(self,selector: "reloadSharedPointsTable", name: "NewSharedDetected", object: sharedBrowser) }

Add reloadSharedPointsTable() method implementation:

func reloadSharedPointsTable() { sharedPointsTable.reloadData() }

mountToShare(sender:) function:

func mountToShare(sender:NSTableView!) { var clickedRow = sender.clickedRow if (clickedRow < 0) || (clickedRow > (sharedBrowser.sharedPointsList.count - 1)) { return } let sharedPoint = sharedBrowser.sharedPointsList.objectAtIndex[clickedRow] let ip = sharedPoint.ipAddress if let a = NSAppleScript(source: "tell application \"Finder\"\ntry\nmount volume \ "\(sharedPoint.type)://\(ip)\"\nend try\nend tell\n") { var errorInfo: NSDictionary? if a.compileAndReturnError(&errorInfo) { if (a.executeAndReturnError(&errorInfo) != nil) { // success } } else { } if errorInfo != nil { NSLog("Error %@",errorInfo!); } } }

Connection to file sharing service is processed via script on AppleScript. There's NSAppleScript class to create and perform scripts in Cocoa applications.

NSAppleScript object creation is performed via init?(source: String) initializer, to which a string with script code is passed.

Application Launch

1. Launch the app by clicking Run button.

2. Click Search button.

3. In the table, you will see computers' names with enabled file sharing, the protocol type used for sharing and their IP addresses.

4. To connect to a definite computer with enabled file sharing, double-click the row corresponding to it. You’ll see the window:

Congrats! That's your first Swift app!

Download the archive with sources of the above described sample here: https://dl.dropboxusercontent.com/u/2191286/SharingBrowser.zip

Subscribe here:

int getNextRandomValue() { srand(time(NULL)); int randomNumber = rand() % 100 + 1; printf("New random number: %i\n",randomNumber); return randomNumber; }

The pointer to this function in C would have int (*)(void) type, while in Swift it will have CFunctionPointer<() -> Int32> type. To create CFunctionPointer, COpaquePointer is needed, e.g.:

let pointer = UnsafeMutablePointer<() -> Int32>.alloc(1) pointer.initialize(getNextRandomValue) let cPointer = COpaquePointer(pointer) let functionPointer = CFunctionPointer<() -> Int32>(cPointer)

To call a function via a pointer to it, do the following:

let newCPointer = COpaquePointer(functionPointer) let newPointer = UnsafeMutablePointer<() -> Int32>(newCPointer) let rNumber = newPointer.memory()

Ok. Now let's turn our eyes to callback functions. Pointers to functions are valued as they can be passed as parameter to other functions. A function passed to another function for calling as pointer is called a callback function. Suppose, we need to track when new disk or partition is created.

Let's create Disk Arbitration session, register DADiskAppearedCallback and pass the object for handling:

func gotDisk(disk: DADisk!, context: UnsafeMutablePointer) { NSLog("Got new disk: \(DADiskGetBSDName(disk))") } … var session = DASessionCreate(kCFAllocatorDefault).takeRetainedValue() let p = UnsafeMutablePointer<((DADisk!, UnsafeMutablePointer) -> Void)>.alloc(1) p.initialize(gotDisk) let cp = COpaquePointer(p) let fp = DADiskAppearedCallback(cp) DARegisterDiskAppearedCallback( session, kDADiskDescriptionMatchVolumeMountable.takeRetainedValue(), fp, nil) /* Schedule a disk arbitration session. */ DASessionScheduleWithRunLoop(session, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode) ...

On handling stage we will get EXC_BAD_ACCESS exception.

Let's see what caused the exception. We'll create our own C-function, which takes pointer of void f(void) type:

void executeFunction(void(*f)(void)) { f(); }

Call this function from Swift, passing a pointer to greeting function as parameter:

func greeting() { NSLog("Hello from Swift") } ... let p = UnsafeMutablePointer<()->()>.alloc(1) p.initialize(greeting) let cp = COpaquePointer(p) let fp = CFunctionPointer<()->()>(cp) executeFunction(fp) ...

On handling stage we'll get EXC_BAD_ACCESS exception again.

In debugger we see that instead of greeting function address, CFunctionPointer address is returned to executeFunction method:

Thus, it seems to be impossible to call a function via CFunctionPointer.

Hope this problem will be resolved in the nearest future. I'll keep you updated.

Subscribe here: