tessl/pypi-pyobjc-framework-multipeerconnectivity

Python wrappers for macOS MultipeerConnectivity framework enabling peer-to-peer networking and device discovery

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

PyObjC Framework MultipeerConnectivity

Name: tessl/pypi-pyobjc-framework-multipeerconnectivity
Author: tessl

Python wrappers for the macOS MultipeerConnectivity framework enabling peer-to-peer networking, device discovery, and data exchange between nearby devices over Wi-Fi, Bluetooth, and infrastructure networks without requiring internet connectivity.

Package Information

Package Name: pyobjc-framework-MultipeerConnectivity
Language: Python with C extensions
Installation: pip install pyobjc-framework-MultipeerConnectivity
Dependencies: pyobjc-core>=10.3.2, pyobjc-framework-Cocoa>=10.3.2
Platform: macOS 10.10+ only
Minimum OS: macOS 10.10 (Yosemite)

Core Imports

import MultipeerConnectivity

Access to specific classes:

from MultipeerConnectivity import (
    MCPeerID, MCSession, MCNearbyServiceAdvertiser, MCNearbyServiceBrowser,
    MCAdvertiserAssistant, MCBrowserViewController
)

Basic Usage

import MultipeerConnectivity
from Foundation import NSData, NSString

# Create a peer ID to identify this device
peer_id = MultipeerConnectivity.MCPeerID.alloc().initWithDisplayName_("MyDevice")

# Create a session for peer-to-peer communication
session = MultipeerConnectivity.MCSession.alloc().initWithPeer_(peer_id)

# Start advertising this device as available for connection
service_type = "my-app-service"
advertiser = MultipeerConnectivity.MCNearbyServiceAdvertiser.alloc().initWithPeer_discoveryInfo_serviceType_(
    peer_id, None, service_type
)

# Start browsing for other peers
browser = MultipeerConnectivity.MCNearbyServiceBrowser.alloc().initWithPeer_serviceType_(
    peer_id, service_type
)

# Send data to connected peers
message = "Hello from Python!"
data = message.encode('utf-8')
nsdata = NSData.alloc().initWithBytes_length_(data, len(data))

connected_peers = session.connectedPeers()
if connected_peers:
    success = session.sendData_toPeers_withMode_error_(
        nsdata, 
        connected_peers, 
        MultipeerConnectivity.MCSessionSendDataReliable,
        None
    )

Architecture

MultipeerConnectivity provides a framework for establishing peer-to-peer networks between devices:

Peer Discovery: Automatic discovery of nearby devices using Bonjour over Wi-Fi and Bluetooth
Session Management: Reliable connection establishment and maintenance between peers
Data Transport: Support for reliable and unreliable data transmission modes
Security: Optional encryption and certificate validation for secure communications
UI Components: Ready-to-use view controllers for peer browsing and connection management

The framework abstracts the underlying network transport (Wi-Fi, Bluetooth, or infrastructure) and provides a unified API for peer-to-peer communication.

Capabilities

Peer Identification

Represents and manages peer identity in the multipeer connectivity network.

class MCPeerID:
    def initWithDisplayName_(self, displayName: str) -> MCPeerID: ...
    def displayName(self) -> str: ...
    def hash(self) -> int: ...
    def isEqual_(self, object: object) -> bool: ...

Session Management

Manages peer-to-peer communication sessions with connection state tracking and data transmission.

class MCSession:
    def initWithPeer_(self, myPeerID: MCPeerID) -> MCSession: ...
    def initWithPeer_securityIdentity_encryptionPreference_(
        self, myPeerID: MCPeerID, 
        identity: object, 
        encryptionPreference: int
    ) -> MCSession: ...
    
    def sendData_toPeers_withMode_error_(
        self, data: NSData, 
        peerIDs: list, 
        mode: int, 
        error: object
    ) -> bool: ...
    
    def disconnect(self) -> None: ...
    def connectedPeers(self) -> list: ...
    def myPeerID(self) -> MCPeerID: ...
    
    def sendResourceAtURL_withName_toPeer_withCompletionHandler_(
        self, resourceURL: NSURL,
        resourceName: str,
        peerID: MCPeerID, 
        completionHandler: callable
    ) -> object: ...
    
    def startStreamWithName_toPeer_error_(
        self, streamName: str,
        peerID: MCPeerID,
        error: object
    ) -> NSOutputStream: ...
    
    def nearbyConnectionDataForPeer_withCompletionHandler_(
        self, peerID: MCPeerID,
        completionHandler: callable
    ) -> None: ...

Service Advertising

Advertises the local peer's availability to nearby devices for connection requests.

class MCNearbyServiceAdvertiser:
    def initWithPeer_discoveryInfo_serviceType_(
        self, myPeerID: MCPeerID,
        info: dict,
        serviceType: str
    ) -> MCNearbyServiceAdvertiser: ...
    
    def startAdvertisingPeer(self) -> None: ...
    def stopAdvertisingPeer(self) -> None: ...
    def delegate(self) -> object: ...
    def setDelegate_(self, delegate: object) -> None: ...
    def myPeerID(self) -> MCPeerID: ...
    def discoveryInfo(self) -> dict: ...
    def serviceType(self) -> str: ...

Service Discovery

Discovers and browses for nearby peers advertising compatible services.

class MCNearbyServiceBrowser:
    def initWithPeer_serviceType_(
        self, myPeerID: MCPeerID,
        serviceType: str
    ) -> MCNearbyServiceBrowser: ...
    
    def startBrowsingForPeers(self) -> None: ...
    def stopBrowsingForPeers(self) -> None: ...
    def invitePeer_toSession_withContext_timeout_(
        self, peerID: MCPeerID,
        session: MCSession,
        context: NSData,
        timeout: float
    ) -> None: ...
    def delegate(self) -> object: ...
    def setDelegate_(self, delegate: object) -> None: ...
    def myPeerID(self) -> MCPeerID: ...
    def serviceType(self) -> str: ...

High-Level Advertising Helper

Simplified interface for advertising peer availability with minimal configuration.

class MCAdvertiserAssistant:
    def initWithServiceType_discoveryInfo_session_(
        self, serviceType: str,
        info: dict,
        session: MCSession
    ) -> MCAdvertiserAssistant: ...
    
    def start(self) -> None: ...
    def stop(self) -> None: ...
    def delegate(self) -> object: ...
    def setDelegate_(self, delegate: object) -> None: ...
    def session(self) -> MCSession: ...
    def discoveryInfo(self) -> dict: ...
    def serviceType(self) -> str: ...

Peer Browser UI

Pre-built user interface for discovering and connecting to nearby peers.

class MCBrowserViewController:
    def initWithServiceType_session_(
        self, serviceType: str,
        session: MCSession
    ) -> MCBrowserViewController: ...
    
    def initWithBrowser_session_(
        self, browser: MCNearbyServiceBrowser,
        session: MCSession
    ) -> MCBrowserViewController: ...
    
    def delegate(self) -> object: ...
    def setDelegate_(self, delegate: object) -> None: ...
    def browser(self) -> MCNearbyServiceBrowser: ...
    def session(self) -> MCSession: ...
    def minimumNumberOfPeers(self) -> int: ...
    def setMinimumNumberOfPeers_(self, minimumNumberOfPeers: int) -> None: ...
    def maximumNumberOfPeers(self) -> int: ...
    def setMaximumNumberOfPeers_(self, maximumNumberOfPeers: int) -> None: ...

Constants and Enums

Session Send Data Modes

MCSessionSendDataReliable: int = 0     # Guaranteed delivery, ordered
MCSessionSendDataUnreliable: int = 1   # Best effort delivery, unordered

Session States

MCSessionStateNotConnected: int = 0    # Peer is not connected
MCSessionStateConnecting: int = 1      # Peer is connecting
MCSessionStateConnected: int = 2       # Peer is connected

Encryption Preferences

MCEncryptionOptional: int = 0          # Encryption preferred but not required
MCEncryptionRequired: int = 1          # Encryption required for connection
MCEncryptionNone: int = 2              # No encryption

Session Limits

kMCSessionMinimumNumberOfPeers: int    # Minimum peers in session (typically 1)
kMCSessionMaximumNumberOfPeers: int    # Maximum peers in session (typically 8)

Error Codes

MCErrorDomain: str                     # Error domain identifier

MCErrorUnknown: int = 0                # Unknown error
MCErrorNotConnected: int = 1           # Peer not connected
MCErrorInvalidParameter: int = 2       # Invalid parameter passed
MCErrorUnsupported: int = 3            # Operation not supported
MCErrorTimedOut: int = 4               # Operation timed out
MCErrorCancelled: int = 5              # Operation was cancelled
MCErrorUnavailable: int = 6            # Service unavailable

Delegate Protocols

MCSessionDelegate

# Required methods
def session_peer_didChangeState_(self, session: MCSession, peerID: MCPeerID, state: int) -> None:
    """Called when a peer changes connection state"""

def session_didReceiveData_fromPeer_(self, session: MCSession, data: NSData, peerID: MCPeerID) -> None:
    """Called when data is received from a peer"""

def session_didReceiveStream_withName_fromPeer_(
    self, session: MCSession, stream: NSInputStream, streamName: str, peerID: MCPeerID
) -> None:
    """Called when a stream is received from a peer"""

def session_didStartReceivingResourceWithName_fromPeer_withProgress_(
    self, session: MCSession, resourceName: str, peerID: MCPeerID, progress: NSProgress
) -> None:
    """Called when starting to receive a resource from a peer"""

def session_didFinishReceivingResourceWithName_fromPeer_atURL_withError_(
    self, session: MCSession, resourceName: str, peerID: MCPeerID, localURL: NSURL, error: NSError
) -> None:
    """Called when finished receiving a resource from a peer"""

# Optional methods
def session_didReceiveCertificate_fromPeer_certificateHandler_(
    self, session: MCSession, certificate: NSArray, peerID: MCPeerID, certificateHandler: callable
) -> None:
    """Called to validate peer certificate for secure connections"""

MCNearbyServiceAdvertiserDelegate

# Required method
def advertiser_didReceiveInvitationFromPeer_withContext_invitationHandler_(
    self, advertiser: MCNearbyServiceAdvertiser, 
    peerID: MCPeerID, 
    context: NSData, 
    invitationHandler: callable
) -> None:
    """Called when receiving an invitation from a peer"""

# Optional method
def advertiser_didNotStartAdvertisingPeer_(
    self, advertiser: MCNearbyServiceAdvertiser, 
    error: NSError
) -> None:
    """Called when advertising fails to start"""

MCNearbyServiceBrowserDelegate

# Required methods
def browser_foundPeer_withDiscoveryInfo_(
    self, browser: MCNearbyServiceBrowser, 
    peerID: MCPeerID, 
    info: dict
) -> None:
    """Called when a peer is discovered"""

def browser_lostPeer_(
    self, browser: MCNearbyServiceBrowser, 
    peerID: MCPeerID
) -> None:
    """Called when a peer is lost"""

# Optional method
def browser_didNotStartBrowsingForPeers_(
    self, browser: MCNearbyServiceBrowser, 
    error: NSError
) -> None:
    """Called when browsing fails to start"""

MCBrowserViewControllerDelegate

# Required methods
def browserViewControllerDidFinish_(self, browserViewController: MCBrowserViewController) -> None:
    """Called when user finishes with browser"""

def browserViewControllerWasCancelled_(self, browserViewController: MCBrowserViewController) -> None:
    """Called when user cancels browser"""

# Optional method
def browserViewController_shouldPresentNearbyPeer_withDiscoveryInfo_(
    self, browserViewController: MCBrowserViewController,
    peerID: MCPeerID,
    info: dict
) -> bool:
    """Called to determine if peer should be shown in browser"""

MCAdvertiserAssistantDelegate

# Optional methods
def advertiserAssistantWillPresentInvitation_(
    self, advertiserAssistant: MCAdvertiserAssistant
) -> None:
    """Called before presenting invitation dialog"""

def advertiserAssistantDidDismissInvitation_(
    self, advertiserAssistant: MCAdvertiserAssistant  
) -> None:
    """Called after dismissing invitation dialog"""

Types

Foundation Types

NSData = object          # Binary data container
NSString = object        # String object  
NSURL = object           # URL reference
NSInputStream = object   # Input stream
NSOutputStream = object  # Output stream
NSProgress = object      # Progress reporting
NSError = object         # Error information
NSArray = object         # Array container

Workspace: tessl
Visibility: Public
Created: 7 months ago
Last updated: 3 months ago
Describes: pkg:pypi/pyobjc-framework-multipeerconnectivity@10.3.x
Publish Source: CLI
Badge