यहां बताया गया है कि मैं XPC का उपयोग करके द्वि-दिशात्मक आईपीसी कैसे कर रहा हूं।
हेल्पर (लॉगिन आइटम) सर्वर या श्रोता है। मुख्य ऐप या कोई अन्य ऐप ग्राहकों को माना जाता है।
हैडर:
मैं निम्नलिखित प्रबंधक बनाया
@class CommXPCManager;
typedef NS_ENUM(NSUInteger, CommXPCErrorType) {
CommXPCErrorInvalid = 1,
CommXPCErrorInterrupted = 2,
CommXPCErrorTermination = 3
};
typedef void (^XPCErrorHandler)(CommXPCManager *mgrXPC, CommXPCErrorType errorType, NSError *error);
typedef void (^XPCMessageHandler)(CommXPCManager *mgrXPC, xpc_object_t event, NSDictionary *message);
typedef void (^XPCConnectionHandler)(CommXPCManager *peerConnection);
@interface CommXPCManager : NSObject
@property (readwrite, copy, nonatomic) XPCErrorHandler errorHandler;
@property (readwrite, copy, nonatomic) XPCMessageHandler messageHandler;
@property (readwrite, copy, nonatomic) XPCConnectionHandler connectionHandler;
@property (readonly, nonatomic) BOOL clientConnection;
@property (readonly, nonatomic) BOOL serverConnection;
@property (readonly, nonatomic) BOOL peerConnection;
@property (readonly, nonatomic) __attribute__((NSObject)) xpc_connection_t connection;
@property (readonly, strong, nonatomic) NSString *connectionName;
@property (readonly, strong, nonatomic) NSNumber *connectionEUID;
@property (readonly, strong, nonatomic) NSNumber *connectionEGID;
@property (readonly, strong, nonatomic) NSNumber *connectionProcessID;
@property (readonly, strong, nonatomic) NSString *connectionAuditSessionID;
- (id) initWithConnection:(xpc_connection_t)aConnection;
- (id) initAsClientWithBundleID:(NSString *)bundleID;
- (id) initAsServer;
- (void) suspendConnection;
- (void) resumeConnection;
- (void) cancelConnection;
- (void) sendMessage:(NSDictionary *)dict;
- (void) sendMessage:(NSDictionary *)dict reply:(void (^)(NSDictionary *replyDict, NSError *error))reply;
+ (void) sendReply:(NSDictionary *)dict forEvent:(xpc_object_t)event;
@end
कार्यान्वयन:
@interface CommXPCManager()
@property (readwrite, nonatomic) BOOL clientConnection;
@property (readwrite, nonatomic) BOOL serverConnection;
@property (readwrite, nonatomic) BOOL peerConnection;
@property (readwrite, strong, nonatomic) __attribute__((NSObject)) dispatch_queue_t dispatchQueue;
@end
@implementation CommXPCManager
@synthesize clientConnection, serverConnection, peerConnection;
@synthesize errorHandler, messageHandler, connectionHandler;
@synthesize connection = _connection;
@synthesize dispatchQueue = _dispatchQueue;
#pragma mark - Message Methods:
- (void) sendMessage:(NSDictionary *)dict {
dispatch_async(self.dispatchQueue, ^{
xpc_object_t message = dict.xObject;
xpc_connection_send_message(_connection, message);
xpc_release(message);
});
}
- (void) sendMessage:(NSDictionary *)dict reply:(void (^)(NSDictionary *replyDict, NSError *error))reply {
dispatch_async(self.dispatchQueue, ^{
xpc_object_t message = dict.xObject;
xpc_connection_send_message_with_reply(_connection, message, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^(xpc_object_t object) {
xpc_type_t type = xpc_get_type(object);
if (type == XPC_TYPE_ERROR) {
/*! @discussion Reply: XPC Error */
reply([NSDictionary dictionary], [NSError errorFromXObject:object]);
} else if (type == XPC_TYPE_DICTIONARY) {
/*! @discussion Reply: XPC Dictionary */
reply([NSDictionary dictionaryFromXObject:object], nil);
}
}); xpc_release(message);
});
}
+ (void) sendReply:(NSDictionary *)dict forEvent:(xpc_object_t)event {
xpc_object_t message = [dict xObjectReply:event];
xpc_connection_t replyConnection = xpc_dictionary_get_remote_connection(message);
xpc_connection_send_message(replyConnection, message);
xpc_release(message);
}
#pragma mark - Connection Methods:
- (void) suspendConnection {
dispatch_async(self.dispatchQueue, ^{ xpc_connection_suspend(_connection); });
}
- (void) resumeConnection {
dispatch_async(self.dispatchQueue, ^{ xpc_connection_resume(_connection); });
}
- (void) cancelConnection {
dispatch_async(self.dispatchQueue, ^{ xpc_connection_cancel(_connection); });
}
#pragma mark - Accessor Overrides:
- (void) setDispatchQueue:(dispatch_queue_t)queue {
if (queue) dispatch_retain(queue);
if (_dispatchQueue) dispatch_release(_dispatchQueue);
_dispatchQueue = queue;
xpc_connection_set_target_queue(self.connection, self.dispatchQueue);
}
#pragma mark - Getter Overrides:
- (NSString *) connectionName {
__block char* name = NULL;
dispatch_sync(self.dispatchQueue, ^{ name = (char*)xpc_connection_get_name(_connection); });
if(!name) return nil;
return [NSString stringWithCString:name encoding:[NSString defaultCStringEncoding]];
}
- (NSNumber *) connectionEUID {
__block uid_t uid = 0;
dispatch_sync(self.dispatchQueue, ^{ uid = xpc_connection_get_euid(_connection); });
return [NSNumber numberWithUnsignedInt:uid];
}
- (NSNumber *) connectionEGID {
__block gid_t egid = 0;
dispatch_sync(self.dispatchQueue, ^{ egid = xpc_connection_get_egid(_connection); });
return [NSNumber numberWithUnsignedInt:egid];
}
- (NSNumber *) connectionProcessID {
__block pid_t pid = 0;
dispatch_sync(self.dispatchQueue, ^{ pid = xpc_connection_get_pid(_connection); });
return [NSNumber numberWithUnsignedInt:pid];
}
- (NSNumber *) connectionAuditSessionID{
__block au_asid_t auasid = 0;
dispatch_sync(self.dispatchQueue, ^{ auasid = xpc_connection_get_asid(_connection); });
return [NSNumber numberWithUnsignedInt:auasid];
}
#pragma mark - Setup Methods:
- (void) setupConnectionHandler:(xpc_connection_t)conn {
__block CommXPCManager *this = self;
xpc_connection_set_event_handler(conn, ^(xpc_object_t object) {
xpc_type_t type = xpc_get_type(object);
if (type == XPC_TYPE_ERROR) {
/*! @discussion Client | Peer: XPC Error */
NSError *xpcError = [NSError errorFromXObject:object];
if (object == XPC_ERROR_CONNECTION_INVALID) {
if (this.errorHandler)
this.errorHandler(this, CommXPCErrorInvalid, xpcError);
} else if (object == XPC_ERROR_CONNECTION_INTERRUPTED) {
if (this.errorHandler)
this.errorHandler(this, CommXPCErrorInterrupted, xpcError);
} else if (object == XPC_ERROR_TERMINATION_IMMINENT) {
if (this.errorHandler)
this.errorHandler(this, CommXPCErrorTermination, xpcError);
}
xpcError = nil; return;
} else if (type == XPC_TYPE_CONNECTION) {
/*! @discussion XPC Server: XPC Connection */
CommXPCManager *xpcPeer = [[CommXPCManager alloc] initWithConnection:object];
if (this.connectionHandler)
this.connectionHandler(xpcPeer);
xpcPeer = nil; return;
} else if (type == XPC_TYPE_DICTIONARY) {
/*! @discussion Client | Peer: XPC Dictionary */
if (this.messageHandler)
this.messageHandler(this, object, [NSDictionary dictionaryFromXObject:object]);
}
});
}
- (void) setupDispatchQueue {
dispatch_queue_t queue = dispatch_queue_create(xpc_connection_get_name(_connection), 0);
self.dispatchQueue = queue;
dispatch_release(queue);
}
- (void) setupConnection:(xpc_connection_t)aConnection {
_connection = xpc_retain(aConnection);
[self setupConnectionHandler:aConnection];
[self setupDispatchQueue];
[self resumeConnection];
}
#pragma mark - Initialization:
- (id) initWithConnection:(xpc_connection_t)aConnection {
if (!aConnection) return nil;
if ((self = [super init])) {
self.peerConnection = YES;
[self setupConnection:aConnection];
} return self;
}
- (id) initAsClientWithBundleID:(NSString *)bundleID {
xpc_connection_t xpcConnection = xpc_connection_create_mach_service([bundleID UTF8String], nil, 0);
if ((self = [super init])) {
self.clientConnection = YES;
[self setupConnection:xpcConnection];
}
xpc_release(xpcConnection);
return self;
}
- (id) initAsServer {
xpc_connection_t xpcConnection = xpc_connection_create_mach_service([[[NSBundle mainBundle] bundleIdentifier] UTF8String],
dispatch_get_main_queue(),
XPC_CONNECTION_MACH_SERVICE_LISTENER);
if ((self = [super init])) {
self.serverConnection = YES;
[self setupConnection:xpcConnection];
}
xpc_release(xpcConnection);
return self;
}
@end
जाहिर है, मैं कुछ श्रेणी के तरीकों जो आत्म व्याख्यात्मक उपयोग कर रहा हूँ। उदाहरण के लिए:
@implementation NSError (CategoryXPCMessage)
+ (NSError *) errorFromXObject:(xpc_object_t)xObject {
char *description = xpc_copy_description(xObject);
NSError *xpcError = [NSError errorWithDomain:NSPOSIXErrorDomain code:EINVAL userInfo:@{
NSLocalizedDescriptionKey:
[NSString stringWithCString:description encoding:[NSString defaultCStringEncoding]] }];
free(description);
return xpcError;
}
@end
ठीक है, यह मैं अपने आप को दोनों क्लाइंट-साइड और सर्वर-साइड के लिए एक इंटरफेस की स्थापना का उपयोग कर। हेडर कुछ इस तरह दिखता है:
- (void) startListenerConnection {
[self stopConnection];
self.managerXPC = [[CommXPCManager alloc] initAsServer];
__block AppXPCInterface *this = self;
self.managerXPC.connectionHandler = ^(CommXPCManager *peerConnection) {
[(NSMutableArray *)this.peerConnections addObject:peerConnection];
peerConnection.messageHandler = ^(CommXPCManager *mgrXPC, xpc_object_t event, NSDictionary *message) {
[this processMessage:message forEvent:event];
};
peerConnection.errorHandler = ^(CommXPCManager *peer, CommXPCErrorType errorType, NSError *error) {
[this processError:error forErrorType:errorType];
[(NSMutableArray *)this.peerConnections removeObject:peer];
};
};
[CommReceptionist postGlobalNote:kAppXPCListenerNoteHello];
}
यहाँ कार्यान्वयन ग्राहक शुरू करने के लिए है:
@class CommXPCManager;
@protocol AppXPCErrorHandler <NSObject>
@required
- (void) handleXPCError:(NSError *)error forType:(CommXPCErrorType)errorType;
@end
static NSString* const kAppXPCKeyReturn = @"AppXPCInterfaceReturn"; // id returnObject
static NSString* const kAppXPCKeyReply = @"AppXPCInterfaceReply"; // NSNumber: BOOL
static NSString* const kAppXPCKeySEL = @"AppXPCInterfaceSelector"; // NSString
static NSString* const kAppXPCKeyArgs = @"AppXPCInterfaceArguments"; // NSArray (Must be xObject compliant)
@interface AppXPCInterface : NSObject
@property (readonly, strong, nonatomic) CommXPCManager *managerXPC;
@property (readonly, strong, nonatomic) NSArray *peerConnections;
- (void) sendMessage:(SEL)aSelector withArgs:(NSArray *)args reply:(void (^)(NSDictionary *replyDict, NSError *error))reply;
- (void) sendMessageToPeers:(SEL)aSelector withArgs:(NSArray *)args reply:(void (^)(NSDictionary *replyDict, NSError *error))reply;
- (id) initWithBundleID:(NSString *)bundleID andDelegate:(id<AppXPCErrorHandler>)object forProtocol:(Protocol *)proto;
- (id) initListenerWithDelegate:(id<AppXPCErrorHandler>)object forProtocol:(Protocol *)proto;
- (void) observeListenerHello:(CommReceptionistNoteBlock)helloBlock;
- (void) removeListenerObserver;
- (void) startClientConnection;
- (void) startListenerConnection;
- (void) stopConnection;
@end
यहाँ कार्यान्वयन श्रोता शुरू करने के लिए है अब यहाँ
- (void) startClientConnection {
[self stopConnection];
self.managerXPC = [[CommXPCManager alloc] initAsClientWithBundleID:self.identifierXPC];
__block AppXPCInterface *this = self;
self.managerXPC.messageHandler = ^(CommXPCManager *mgrXPC, xpc_object_t event, NSDictionary *message) {
[this processMessage:message forEvent:event];
};
self.managerXPC.errorHandler = ^(CommXPCManager *mgrXPC, CommXPCErrorType errorType, NSError *error) {
[this processError:error forErrorType:errorType];
};
}
आदेश है की चीज़ों का।
- आपका मुख्य अनुप्रयोग सहायक अपने bundleID < का उपयोग कर सुन शुरू होता है इसकी सहायक शुरू होता है --- महत्वपूर्ण!
- मुख्य अनुप्रयोग एक वैश्विक अधिसूचना के लिए सुनता है और फिर संदेश
- ग्राहक संदेश कनेक्शन
स्थापित है अब सर्वर क्लाइंट के लिए संदेश भेज सकते हैं भेजता है और ग्राहक संदेश भेज सकते हैं जब भेजता है सर्वर पर (उत्तर के साथ या बिना)।
यह बहुत तेज़ है, यह अच्छी तरह से काम करता है, और ओएस एक्स 10.7.3 या इससे अधिक के लिए डिज़ाइन किया गया है।
कुछ नोट:
- सहायक के नाम बंडल आईडी के रूप में एक ही नाम होना चाहिए
- नाम अपनी टीम आईडी
- सैंडबॉक्सिंग के लिए, दोनों मुख्य अनुप्रयोग के साथ शुरू होगा और सहायक ऐप एप्लिकेशन समूह सेटिंग सहायक बंडल आईडी
जैसे उपसर्ग के साथ शुरू होना चाहिए हेल्पर बंडल आईडी है: ABC123XYZ.CompanyName.GroupName.Helper अनुप्रयोग समूह आईडी होगा: ABC123XYZ.CompanyName.GroupName
इतनी के रूप में किसी को भी नहीं बोर करने के लिए
अतिरिक्त विवरण मैं बाहर छोड़ दिया वहाँ रहे हैं। लेकिन अगर यह अभी भी अस्पष्ट है तो पूछो और मैं जवाब दूंगा।
ठीक है, उम्मीद है कि इससे मदद मिलती है। अर्विन
ऐसा लगता है कि किसी ने ऐसा करने के लिए हासिल किया है ... http: //stackoverflow.com/questions/8491361/exc-bad-instruction-when-sending-message-to-xpc-service – poorDeveloper
हालांकि अभी भी यह नहीं पता कि इसे कैसे करें ... – poorDeveloper
यदि आपके पास वास्तव में कोई है अभिभावक-बाल संबंध, तो XPC आपके लिए है, लेकिन यदि आपके पास दो स्वतंत्र प्रक्रियाएं हैं, तो XPC जाने का कोई तरीका नहीं है। मैक माइक्रोस्कोनल पर मैकोज़ बेस और इसलिए इसमें एक बहुत ही शक्तिशाली आईपीसी तंत्र है, जो कि किसी भी चीज़ से तेज़ तरीका है: मैक संदेश। यह सॉकेट पर डेटा भेजने की तरह थोड़ा काम करता है लेकिन आप इसे आपके लिए साझा मेमोरी के माध्यम से डेटा स्थानांतरित कर सकते हैं (जो लिखने पर प्रतिलिपि होगी)। यह थोड़ा खराब दस्तावेज है और अवधारणाएं पहले जटिल हैं, लेकिन यह सीखने लायक है।मैकोज़ में अन्य सभी आईपीसी वास्तव में मैक संदेशों के शीर्ष पर लागू किए गए हैं। – Mecki