gliechtenstein
commented
7 years ago @seletz Just want to clarify first, with your example I'm thinking you were envisioning something like this?
{
"$jason": {
"head": {
"actions": {
"$load": {
"type": "@JasonetteWebSocketPlugin.connect",
"options": {
"url": "wss://example.com/ws/echo"
}
},
"!WebSocket.message": {
"type": "$set",
"options": {
"messages": "{{var messages = $get.messages; messages.push($jason); return messages;}}"
},
"success": {
"type": "$render"
}
}
}
}
}
}I think it's best if we walk through using the new notification based action extension code
1. Add call handler to core
First, we could add a Jason.call notification and a notifyCall: method.
- (id)init {
if (self = [super init]) {
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(onForeground) name:UIApplicationDidBecomeActiveNotification object:nil];
self.searchMode = NO;
// Add observers for public API
[[NSNotificationCenter defaultCenter]
addObserver:self
selector:@selector(notifySuccess:)
name:@"Jason.success"
object:nil];
[[NSNotificationCenter defaultCenter]
addObserver:self
selector:@selector(notifyError:)
name:@"Jason.error"
object:nil];
[[NSNotificationCenter defaultCenter]
addObserver:self
selector:@selector(notifyCall:)
name:@"Jason.call"
object:nil];
}
return self;
}
#pragma mark - Jason Core API Notifications
- (void)notifySuccess:(NSNotification *)notification {
NSDictionary *args = notification.object;
NSLog(@"JasonCore: notifySuccess: %@", args);
[[Jason client] success:args];
}
- (void)notifyError:(NSNotification *)notification {
NSDictionary *args = notification.object;
NSLog(@"JasonCore: notifyError: %@", args);
[[Jason client] error:args];
}
- (void)notifyCall:(NSNotification *)notification {
NSDictionary *args = notification.object;
NSLog(@"JasonCore: notifyCall: %@", args);
[[Jason client] call:args];
}2. Extension code
Then, from the extension side we can add another method (which will be triggered automatically by another method in the extension class, for example a new message from Websocket could call this method) which will then post a Jason.call notification with a trigger, along with the payload as options, like this:
- (void)newMessage:(NSDictionary *)message {
NSDictionary *args = notification.userInfo;
NSDictionary *options = args[@"options"];
NSLog(@"JasonetteDemoAction: text: %@", message);
[[NSNotificationCenter defaultCenter]
postNotificationName:@"Jason.call"
object:self
userInfo:@{
@"trigger": @"!WebSocket.message",
@"options": {@"message": message}
}];
}This will kick off a new action call chain that looks like this:
{
"trigger": "!WebSocket.message",
"options": {
"message": "..."
}
}By the way, we already have an event registry tied to the view controller: VC.events, and trigger is already implemented in a way that it can accept an options object and pass it along to the resolved action after lookup, so it should work out of the box without further complication.
3. Teardown
Lastly, we have a detach: method which takes care of cleanup on viewWillDisappear: events. So I think we can just place a post notification line in there some where, like this:
[[NSNotificationCenter defaultCenter]
postNotificationName:@"Jason.kill"
object:self
userInfo:nil];and go back to the extension code and add something like this:
[[NSNotificationCenter defaultCenter]
addObserver: self
selector:@selector(kill:)
name:@"Jason.kill"
object:nil];
...
- (void)kill{
[[NSNotificationCenter defaultCenter]
removeObserver:self
name:@"!WebSocket.message"
object:nil];
}
I haven't yet tried this and it just came straight from head so there may be some mistakes, but theoretically I think this should work...so let me know if I'm missing something.
I couldn't actually try it because I was waiting for your pull request haha
seletz
Motivation
So it looks like the plug-in approach #26 will use notifications to communicate with the core. This opens new possibilities for integrations. For example, issue #49 is about web socket support. Such a feature can live in a plug-in w/o problems.
However, web sockets are async in nature, that is, they can receive messages at any time. How would users be able to react on those events?
Note: I use WebSocket as an example here. This is obviously useful for catching other events and could replace the hard-coded "system events" in Jasonette.
Proposal
I propose a new action type for events. Those actions would "register" itself for a notification handler by name:
Details
For the above to work, the hypothetical WebSocket plugin would send a notification on received messages with name
WebSocket.message.The
!WebSocket.messageaction would instruct the core to register a notification handler for theWebSocket.messagenotification and do a[[Jason client] success:notification.object]if the notification is received. This can be nicely done in a block.All this could be done in a plug-in also. But this ia s feature which is core-worthy IMHO 😄
Problems