Merge pull request #213 from arenaxr/private-objs

Add private message support

Author: hi-liang

arena/objects/arena_object.py

@@ -13,6 +13,7 @@ class Object(BaseObject):
     type = "object"
     object_type = "entity"
     all_objects = {} # dict of all objects created so far
+    private_objects = {} # dict of all private objects created so far
 
     def __init__(self, evt_handler=None, update_handler=None, **kwargs):
         # "object_id" is required in kwargs, defaulted to random uuid4
@@ -31,6 +32,12 @@ def __init__(self, evt_handler=None, update_handler=None, **kwargs):
         ttl = kwargs.get("ttl", None)
         if "ttl" in kwargs: del kwargs["ttl"]
 
+        private = kwargs.get("private", False)
+        if "private" in kwargs: del kwargs["private"]
+
+        private_userid = kwargs.get("private_userid", None)
+        if "private_userid" in kwargs: del kwargs["private_userid"]
+
         # remove timestamp, if exists
         if "timestamp" in kwargs: del kwargs["timestamp"]
 
@@ -71,12 +78,24 @@ def __init__(self, evt_handler=None, update_handler=None, **kwargs):
         if ttl:
             self.ttl = ttl
 
+        # This is with regard to its interaction
+        if private:
+            # Note: public objects *can* have private clicks, mouseover, etc.
+            self.private = private
+
+        if private_userid:
+            self._private_userid = private_userid  # None is public
+            self.private = True # private objects are always private interaction
+
         self.evt_handler = evt_handler
         self.update_handler = update_handler
         self.animations = []
 
         # add current object to all_objects dict
         Object.add(self)
+        # If private, add to private_objects dict
+        if private_userid:
+            Object.add_private(self)
 
         self.delayed_prop_tasks = {}  # dict of delayed property tasks
 
@@ -90,10 +109,22 @@ def update_attributes(self, evt_handler=None, update_handler=None, **kwargs):
         if "data" not in self:
             return
 
-        # update "persist", and "ttl"
-        self.persist = kwargs.get("persist", self.persist)
-        if "ttl" in self:
-            self.ttl = kwargs.get("ttl", self.ttl)
+        if "persist" in kwargs:
+            del kwargs["persist"]
+            self.persist = kwargs.get("private")
+
+        if "ttl" in kwargs:
+            del kwargs["ttl"]
+            self.ttl = kwargs.get("ttl")
+
+        if "private" in kwargs:
+            del kwargs["private"]
+            self.private = kwargs.get("private")
+
+        if "private_userid" in kwargs:
+            del kwargs["private_userid"]
+            self._private_userid = kwargs.get("private_userid")
+            self.private = True
 
         data = self.data
         Data.update_data(data, kwargs)
@@ -122,7 +153,7 @@ def clickable(self):
 
     def json_preprocess(self, **kwargs):
         # kwargs are for additional param to add to json, like "action":"create"
-        skipped_keys = ["evt_handler", "update_handler", "animations", "delayed_prop_tasks"]
+        skipped_keys = ["evt_handler", "update_handler", "animations", "delayed_prop_tasks", "_private_userid"]
         json_payload = {k: v for k, v in vars(self).items() if k not in skipped_keys}
         json_payload.update(kwargs)
         return json_payload
@@ -194,6 +225,15 @@ def add(cls, obj):
         object_id = obj.object_id
         Object.all_objects[object_id] = obj
 
+    @classmethod
+    def add_private(cls, obj):
+        private_userid = getattr(obj, "_private_userid", None)
+        if private_userid is None:
+            raise ValueError("No private user id specified")
+        if private_userid not in Object.private_objects:
+            raise ValueError(f"User {private_userid} does not exist")
+        Object.private_objects[private_userid][obj.object_id] = obj
+
     @classmethod
     def remove(cls, obj):
         object_id = obj.object_id

arena/scene.py

@@ -291,6 +291,7 @@ async def process_message(self):
                         elif action == "leave":
                             # special user presence message, new way to remove user
                             if object_id in self.users:
+                                self.delete_user_objects(object_id)
                                 if self.user_left_callback:
                                     self.callback_wrapper(self.user_left_callback, self.users[object_id], payload)
                                 del self.users[object_id]
@@ -347,6 +348,7 @@ async def process_message(self):
                                     self.users[object_id] = obj
                                 else:
                                     self.users[object_id] = Camera(**payload)
+                                self.reset_private_objects(object_id)
 
                                 if self.user_join_callback:
                                     self.callback_wrapper(self.user_join_callback, self.users[object_id], payload)
@@ -463,10 +465,24 @@ def all_objects(self):
         """Returns all the objects in a scene"""
         return Object.all_objects
 
+    def get_private_objects(self, userid=None):
+        """ Returns all private user objects"""
+        if userid is not None:
+            return Object.private_objects.get(userid, None)
+        else:
+            return Object.private_objects
+
+    def reset_private_objects(self, userid):
+        """Resets all private user objects"""
+        Object.private_objects[userid] = {}
+
     def add_object(self, obj):
         """Public function to create an object"""
         if not isinstance(obj, Object):
             raise ValueError(f"Not a valid ARENA object to add to scene: {type(obj)}")
+        # We have to set program_id here, as only scene has access to its userid
+        if getattr(obj, "private", True):
+            obj.program_id = self.userid
         res = self._publish(obj, "create")
         self.run_animations(obj)
         return res
@@ -482,6 +498,10 @@ def update_object(self, obj: Object, **kwargs):
         if kwargs:
             obj.update_attributes(**kwargs)
 
+        # We have to update program_id here, as only scene has access to its userid
+        if getattr(obj, "private", True):
+            obj.program_id = self.userid
+
         # Check if any keys in delayed_prop_tasks are pending new animations
         # and cancel corresponding final update tasks or, if they are in
         # kwarg property updates, cancel the task as well as the animation
@@ -518,6 +538,13 @@ def delete_object(self, obj):
         Object.remove(obj)
         return self._publish(payload, "delete", custom_payload=True)
 
+    def delete_user_objects(self, userid):
+        """Deletes any private user objects"""
+        if userid in Object.private_objects:
+            for obj in Object.private_objects[userid].keys():
+                Object.all_objects.pop(obj, None)
+        del Object.private_objects[userid]
+
     def delete_program(self, obj):
         type=None
         try:
@@ -611,12 +638,17 @@ def _publish(self, obj: Object, action, custom_payload=False, publish_topic=PUBL
         with self.telemetry.start_publish_span(obj["object_id"], action, obj_type) as span:
             topic = publish_topic.substitute({**self.topicParams, **{"objectId": obj["object_id"]}})
 
-            # self.can_publish_obj indicates if we can publish on the default publish_topic (PUBLISH_TOPICS.SCENE_OBJECTS)
-            if not self.can_publish_obj and publish_topic==PUBLISH_TOPICS.SCENE_OBJECTS:
-                self.telemetry.set_error(
-                    f"ERROR: Publish failed! You do not have permission to publish to topic {topic} on {self.web_host}",
-                    span,
-                )
+            if publish_topic == PUBLISH_TOPICS.SCENE_OBJECTS:
+                # self.can_publish_obj indicates if we can publish on the default publish_topic (PUBLISH_TOPICS.SCENE_OBJECTS)
+                if not self.can_publish_obj:
+                    self.telemetry.set_error(
+                        f"ERROR: Publish failed! You do not have permission to publish to topic {topic} on {self.web_host}",
+                        span,
+                    )
+                elif hasattr(obj, "_private_userid"):
+                    topic = PUBLISH_TOPICS.SCENE_OBJECTS_PRIVATE.substitute(
+                        {**self.topicParams, **{"objectId": obj['object_id'], "toUid": obj['_private_userid']}}
+                    )
 
             d = datetime.utcnow().isoformat()[:-3] + "Z"
 

examples/simple/private-objs.py

@@ -0,0 +1,54 @@
+from arena import *
+import random
+
+
+def user_leave_callback(scene, cam, msg):
+    print("left:", cam.object_id)
+    print("Private Objects:", scene.get_private_objects())
+
+def report_click(scene, evt, msg):
+    if evt.type == "mousedown":
+        print(f"User {evt.object_id} clicked on {evt.data.target}")
+
+def user_join_callback(scene, cam, msg):
+    username = cam.object_id
+    print("joined:", username)
+    random_y = 0.5 + random.randrange(3)
+    random_z = -1 - random.randrange(5)
+    # Text that only user can see
+    user_text = Text(
+        object_id=f"text_{username}",
+        value=f"Hello {username}!",
+        align="center",
+        font="mozillavr",
+        # https://aframe.io/docs/1.4.0/components/text.html#stock-fonts
+        position=(0, random_y, random_z),
+        scale=(1.5, 1.5, 1.5),
+        color=(100, 255, 255),
+        private_userid=username,
+    )
+    # Clickable box that only user can see
+    user_box = Box(
+        object_id=f"box_{username}",
+        position=(0, 0.75 + random_y, random_z),
+        scale=(0.5, 0.5, 0.5),
+        color=(100, 255, 255),
+        private_userid=username,
+        clickable=True,
+        evt_handler=report_click,
+    )
+    # Red box that everyone can see
+    user_public_box = Box(
+        object_id=f"box_{username}_public",
+        position=(0, 1.25 + random_y, random_z),
+        scale=(0.5, 0.5, 0.5),
+        color=(255, 0, 0),
+    )
+    scene.add_objects([user_text, user_box, user_public_box])
+    print("Private Objects:", scene.get_private_objects())
+
+scene = Scene(host="arenaxr.org", scene="example")
+scene.user_join_callback = user_join_callback
+scene.user_left_callback = user_leave_callback
+
+scene.run_tasks()