Multipeer Connectivity Framework - Sharing Custom Classes

Custom Class

import UIKit

//MARK: MultiPeer_CustomClass
class MultiPeer_CustomClass : NSObject
{
    //MARK: Local Variables
    var name : String?
    var age : Int?
    var email : String?
    
    // Decode
    required convenience init(coder decoder: NSCoder)
    {
        self.init()
        
        if let proper_name = decoder.decodeObjectForKey("name") as? String
        {
            self.name = proper_name
        }
        
        if let proper_age = decoder.decodeObjectForKey("age") as? Int
        {
            self.age = proper_age
        }
        
        if let proper_email = decoder.decodeObjectForKey("email") as? String
        {
            self.email = proper_email
        }
    }
    
    // Init
    convenience init(name : String, age : Int, email : String)
    {
        self.init()
        
        self.name = name
        self.age = age
        self.email = email
    }
    
    // Encode
    func encodeWithCoder(coder : NSCoder)
    {
        if let proper_name = self.name
        {
            coder.encodeObject(proper_name, forKey: "name")
        }
        
        if let proper_age = self.age
        {
            coder.encodeObject(proper_age, forKey: "age")
        }
        
        if let proper_email = self.email
        {
            coder.encodeObject(proper_email, forKey: "email")
        }
    }
}

Helper Functions

  // Converting Custom Class to NSData
    
    class func convertCustomClassToNSData(customClass classObject : AnyObject) -> NSData
    {
        let data : NSData = NSKeyedArchiver.archivedDataWithRootObject(classObject)
        return data
    }
    
    // Converting NSData Custo Class
    
    class func convertNSDataToCustomClass(data dataValue : NSData) -> AnyObject?
    {
        let dict = NSKeyedUnarchiver.unarchiveObjectWithData(dataValue) as? AnyObject
        return dict
    }

Multipeer Model Class

import UIKit
import MultipeerConnectivity

//MARK: MCNearbyServiceAdvertiserDelegate
extension MultiPeerHelper : MCNearbyServiceAdvertiserDelegate
{
    // Incoming invitation request.  Call the invitationHandler block with YES
    // and a valid session to connect the inviting peer to the session.
    
    func advertiser(advertiser: MCNearbyServiceAdvertiser, didReceiveInvitationFromPeer peerID: MCPeerID, withContext context: NSData?, invitationHandler: (Bool, MCSession) -> Void)
    {
        invitationHandler(true, self.session) // Accepting an invitation
    }
    
    // Advertising did not start due to an error.
    
    func advertiser(advertiser: MCNearbyServiceAdvertiser, didNotStartAdvertisingPeer error: NSError)
    {
    }
}

//MARK: MCNearbyServiceBrowserDelegate
extension MultiPeerHelper : MCNearbyServiceBrowserDelegate
{
    // Found a nearby advertising peer.
    
    func browser(browser: MCNearbyServiceBrowser, foundPeer peerID: MCPeerID, withDiscoveryInfo info: [String : String]?)
    {
        browser.invitePeer(peerID, toSession: self.session, withContext: nil, timeout: 10) // Inviting a peer to connect to my session
    }
    
    // A nearby peer has stopped advertising.
    
    func browser(browser: MCNearbyServiceBrowser, lostPeer peerID: MCPeerID)
    {
        // Lost
    }
    
    // Browsing did not start due to an error.
    
    func browser(browser: MCNearbyServiceBrowser, didNotStartBrowsingForPeers error: NSError)
    {
        // Error
    }
}

//MARK: MCSessionDelegate
extension MultiPeerHelper : MCSessionDelegate
{
    // Remote peer changed state.
    func session(session: MCSession, peer peerID: MCPeerID, didChangeState state: MCSessionState)
    {
        switch state
        {
            
        case MCSessionState.Connected:
            
            print("Connected: \(peerID.displayName)")
            
        case MCSessionState.Connecting:
            
            print("Connecting: \(peerID.displayName)")
            
        case MCSessionState.NotConnected:
            
            print("Not Connected: \(peerID.displayName)")
        }
    }
    
    // Received data from remote peer.
    func session(session: MCSession, didReceiveData data: NSData, fromPeer peerID: MCPeerID)
    {
        // Recieved data
    }
    
    // Received a byte stream from remote peer.
    func session(session: MCSession, didReceiveStream stream: NSInputStream, withName streamName: String, fromPeer peerID: MCPeerID)
    {
    }
    
    // Start receiving a resource from remote peer.
    func session(session: MCSession, didStartReceivingResourceWithName resourceName: String, fromPeer peerID: MCPeerID, withProgress progress: NSProgress)
    {
    }
    
    // Finished receiving a resource from remote peer and saved the content
    // in a temporary location - the app is responsible for moving the file
    // to a permanent location within its sandbox.
    func session(session: MCSession, didFinishReceivingResourceWithName resourceName: String, fromPeer peerID: MCPeerID, atURL localURL: NSURL, withError error: NSError?)
    {
    }
    
    // Made first contact with peer and have identity information about the
    // remote peer (certificate may be nil).
    func session(session: MCSession, didReceiveCertificate certificate: [AnyObject]?, fromPeer peerID: MCPeerID, certificateHandler: (Bool) -> Void)
    {
        certificateHandler(true)
    }
}

//MARK: ViewController

class MultiPeerHelper: NSObject {
    
    // Singleton
    
    static let sharedInstance = MultiPeerHelper()

    private enum MPCServiceType : String
    {
        case Update = "MPCUpdate"
    }
    
    // Peer Id
    var myOwnPeerId : MCPeerID!

    // For finding the devices
    var serviceAdvertiser : MCNearbyServiceAdvertiser!
    
    // For listening to devices
    var serviceBrowser : MCNearbyServiceBrowser!
    
    // Session
    lazy var session : MCSession = {
        
        let session = MCSession(peer: self.myOwnPeerId, securityIdentity: nil, encryptionPreference: MCEncryptionPreference.Optional)
        session.delegate = self
        return session
    }()
    
    override init()  {
        
        self.myOwnPeerId = MCPeerID(displayName: "EHR - \(UIDevice.currentDevice().name)")
        
        // Advertising
        
        self.serviceAdvertiser = MCNearbyServiceAdvertiser(peer: self.myOwnPeerId, discoveryInfo: nil, serviceType: MPCServiceType.Update.rawValue)
        
        // Browsing
        
        self.serviceBrowser = MCNearbyServiceBrowser(peer: self.myOwnPeerId, serviceType: MPCServiceType.Update.rawValue)
        
        super.init()
        
        // Browsing
        
        self.serviceBrowser.delegate = self
        self.serviceBrowser.startBrowsingForPeers() // Starting browsing...
        
        // Avertising
        
        self.serviceAdvertiser.delegate = self
        self.serviceAdvertiser.startAdvertisingPeer() // Starting advertising...
    }
    
    
    //MARK: Send data to peer
    func sendDataToDevice(data dataObject : NSData, peedId : MCPeerID)
    {
        do
        {
            try self.session.sendData(dataObject , toPeers: [peedId], withMode: MCSessionSendDataMode.Reliable)
        }
        catch
        {
            // Hanldle error
        }
    }
}

ViewController

import UIKit

class ViewController: UIViewController
{
    override func viewDidLoad()
    {
        super.viewDidLoad()
        MultiPeerHelper.sharedInstance.startBrowsingAndAdvertising()
    }
    
    func buttonClicked()
    {
        // Sending Data
        
        let object = MultiPeer_CustomClass(name: "Alvin Varghese", age: 23, email: "alvin@nfnlabs.in")
        let data : NSData = NSKeyedArchiver.archivedDataWithRootObject(object)
        
        let connectedPeer = MultiPeerHelper.sharedInstance.session.connectedPeers.first // Connected Peer
        
        MultiPeerHelper.sharedInstance.sendDataToDevice(data: data, peedId: connectedPeer!)
    }
}