Joe Kaplan

I'm using MIN to build a package of Max externals and I'd like to make use of Max's notification system.

I found the relevant functions in the C API docs.

I discovered that these functions are accessible in MIN using the "c74::max" namespace. But I'm having some difficulty implementing them.

automatically defining a t_object for the present class. 

But I'm not sure what the syntax is to access it in my register function?

I'm struggling to understand how to initializes the arguments to that function. Particularly the names parameter which takes type t_symbol***.

I'm sure a lot of this is just my own unfamiliarity with C and C++, but I'm struggling to get this going from the present documentation.

Are there any code examples available that show the Notifications system in action in MIN? Min-Devkit includes some buffer~ related objects that show a framework for receiving notifications. But I'm not finding any examples of how to register objects in a namespace, view a list of registered objects in a namespace, or send notifications.

I'm using MIN to build a package of Max externals and I'd like to make use of Max's notification system.  

 I found the relevant functions in the C API docs.  

 object_notify()
object_attach()
object_register()
object_subscribe()
 object_register_getnames() 

I discovered that these functions are accessible in MIN using the "c74::max" namespace.  But I'm having some difficulty implementing them.  

For example, it looks like MIN is automatically defining a t_object for the present class. 
But I'm not sure what the syntax is to access it in my register function?

Also, I'm looking at the  object_register_getnames().
I'm struggling to understand how to initializes the arguments to that function.  Particularly the names parameter which takes type t_symbol***.

 Are there any code examples available that show the Notifications system in action in MIN?  Min-Devkit includes some buffer~ related objects that show a framework for receiving notifications.  But I'm not finding any examples of how to register objects in a namespace, view a list of registered objects in a namespace, or send notifications.

Greetings,
I'm using MIN to build a package of Max externals and I'd like to make use of Max's notification system.  
 I found the relevant 

working-with-notifications-in-min-how-to-register-register_getnames-and-attach

 to return the t_object pointer from your min class.

calling object_register from your class would look something like: 

c74::max::object_register(namespace_sym, name_sym, maxobj());

I'm not sure of any code examples using Min, but the max-sdk demonstrate this, and the basic functionality is the same in both sdks.

basic usage of getnames is something like this:

long        namecount = 0;
t_symbol    **names = NULL;
t_max_err err = object_register_getnames(namespace_sym, &namecount, &names);
if (!err && names) {
    for (i=0; i<namecount; i++) {
        t_symbol *name = names[i];
    }
}

you can use the the min function maxobj() to return the t_object pointer from your min class.
calling object_register from your class would look something like: c74::max::object_register(namespace_sym, name_sym, maxobj());

I'm not sure of any code examples using Min, but the max-sdk demonstrate this, and the basic functionality is the same in both sdks. 

long		namecount = 0;
t_symbol	**names = NULL;
t_max_err err = object_register_getnames(namespace_sym, &namecount, &names);
if (!err && names) {
	for (i=0; i<namecount; i++) {
		t_symbol *name = names[i];
	}
}

Thanks Rob. This is super helpful! I gave it a shot, but was unsuccessful. Perhaps you can help me see where I'm going wrong? I have two objects.

message<> maxclass_setup { this, "maxclass_setup",
        MIN_FUNCTION {
            c74::max::t_symbol* Namespace = c74::max::gensym("Namespace");
            c74::max::t_symbol* sender = c74::max::gensym("sender");
            c74::max::object_register(Namespace, sender, maxobj());
            return {};
        }
    };
    
message<> bang{ this, "bang", "Post the greeting.",
        MIN_FUNCTION {
            c74::max::t_symbol* notification = c74::max::gensym("well, hello");
            c74::max::object_notify(maxobj(), notification, NULL);
            return {};
        }
    };

message<> maxclass_setup{ this, "maxclass_setup",
        MIN_FUNCTION {
            c74::max::t_symbol * Namespace = c74::max::gensym("Namespace");
            c74::max::t_symbol* sender = c74::max::gensym("sender");
            c74::max::object_attach(Namespace, sender, maxobj());
            return {};
        }
    };
    
message<> notify { this, "notify", "Receive a Notification.",
        MIN_FUNCTION {
            cout << "notified" << endl;
            notification n {args};
            cout << "received notification from " << n.source() << endl;
            cout << "it said " << n.name() << endl;
            return {};
        }
    };

The idea is that the "Send" object gets registered to the "Namespace" namespace with the name "sender" when the object is loaded. The receive object attached to the object named "sender" in the namespace "Namespace".

Then when "Send" gets a bang, "Recieve" gets a notification and posts a bunch of stuff to the Max window.

This code builds happily and I can create the objects in Max. But when I give my sending object a bang, nothing happens.

Thanks Rob.  This is super helpful!  I gave it a shot, but was unsuccessful.   Perhaps you can help me see where I'm going wrong?  I have two objects.

The idea is that the "Send" object gets registered to the "Namespace" namespace with the name "sender" when the object is loaded.   The receive object attached to the object named "sender" in the namespace "Namespace".

This code builds happily and I can create the objects in Max.  But when I give my sending object a bang, nothing happens.

can you zip up your project source and send my way? you can do this privately if you prefer, my email is linked in my profile (click on the avatar).

ok you were mostly there but there were a few fundamental issues. You should be calling these registration and attach functions in object context (e.g. an object constructor) not class context (e.g. maxclass_setup) as you were doing. you can step into the code for maxobj() and see it is returning NULL if called from maxclass_setup.

if you move the code for both classes to a constructor function you will be getting close. The other issue is that depending on your use case, you may wish to use object_subscribe rather than object_register. If you register rather than subscribe, the registration functionality is dependent on the server object being created prior to the client. if you use subscribe there is no dependence on order.

i'm assuming this example is simply for testing, and that your real implementation will provide proper unique id as the server name, and test for return values from the api calls for success.

one minor caveat related to min is that dummy objects are created that will call the constructor one time as part of the class initialization. in this case maxobj() will return NULL, and therefore no registration or subscription will take place in those dummy constructors (since passing NULL to those calls fails silently, there is no issue) but you could test maxobj() output if desired and necessary, to ensure you are not in the dummy constructor.

NotificationsTest2_Send() {
    c74::max::t_symbol* Namespace = c74::max::gensym("Namespace");
    c74::max::t_symbol* sender = c74::max::gensym("sender");
    c74::max::object_register(Namespace, sender, maxobj());
}

....

NotificationsTest2_Receive() {
    c74::max::t_symbol* Namespace = c74::max::gensym("Namespace");
    c74::max::t_symbol* sender = c74::max::gensym("sender");
    c74::max::object_subscribe(Namespace, sender, c74::max::gensym("NotificationsTest2.Send"), maxobj());
}

NotificationsTest2_Send() {
	c74::max::t_symbol* Namespace = c74::max::gensym("Namespace");
	c74::max::t_symbol* sender = c74::max::gensym("sender");
	c74::max::object_register(Namespace, sender, maxobj());
}

....

NotificationsTest2_Receive() {
	c74::max::t_symbol* Namespace = c74::max::gensym("Namespace");
	c74::max::t_symbol* sender = c74::max::gensym("sender");
	c74::max::object_subscribe(Namespace, sender, c74::max::gensym("NotificationsTest2.Send"), maxobj());
}

Rob, this works! I can't believe it! I think I can get on with building my project now. I'm so relieved. Thank you!

A couple of housekeeping questions from the novice programmer:

Yes. I had considered this. Though I haven't yet thought through how to achieve it. Do you have any suggestions for how to get a count of how many instances of an object are currently in the patch? I could use that to generate the server names. Or, come to think it, perhaps this is where object_register_getnames() comes in handy.

I had not considered this. It looks like all of these functions return a pointer to the registered server object. If I'm understanding you correctly, I should test make sure I get back a pointer to the registered server object and not "NULL" or something else? Is that on the right track?

 If I'm understanding correctly, I need to watch out for this if I'm doing other logic in my constructor that might fail less silently if maxobj() is null. Is that right?

Rob, this works!  I can't believe it!   I think I can get on with building my project now.  I'm so relieved.  Thank you! 

 i'm assuming this example is simply for testing, and that your real implementation will provide proper unique id as the server name, 

 Yes.  I had considered this.  Though I haven't yet thought through how to achieve it.  Do you have any suggestions for how to get a count  of how many instances of an object are currently in the patch?   I could use that to generate the server names.   Or, come to think it, perhaps this is where object_register_getnames() comes in handy.

 and test for return values from the api calls for success. 

I had not considered this.  It looks like all of these functions return a pointer to the registered server object.  If I'm understanding you correctly, I should test make sure I get back a pointer to the registered server object and not "NULL" or something else?  Is that on the right track?

 one minor caveat related to min is that dummy objects are created that will call the constructor one time as part of the class initialization. 

I read about this in the Min Documentation for writing objects.   If I'm understanding correctly,  I need to watch out for this if I'm doing other logic in my constructor that might fail less silently if maxobj() is null.  Is that right?

Working with Notifications in Min: How to register, register_getnames, and attach?