SyncObject.cs

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.

#if UNITY_WINRT && !UNITY_EDITOR
#define USE_WINRT
#endif

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Reflection;
using UnityEngine;
using UnityEngine.Assertions;
using HoloToolkit.Unity;

namespace HoloToolkit.Sharing.SyncModel
{
    public class SyncObject : SyncPrimitive
    {
        private ObjectElementAdapter syncListener;                 // The sync object that we use to get sync events for this element
        private Dictionary<long, SyncPrimitive> primitiveMap;      // A dictionary of all of the primitives that are children of this object.  Maps element GUID to data
        private List<SyncPrimitive> primitives;                    // Raw list of child primitives

        public event Action<SyncObject> ObjectChanged;             // Invoked when one of the child primitives has changed
        public event Action<SyncObject> InitializationComplete;    // Invoked when this object has been fully initialized

        private ObjectElement internalObjectElement;
        public ObjectElement Element
        {
            get { return internalObjectElement; }
            internal set
            {
                if (internalObjectElement == null)
                {
                    internalObjectElement = value;
                    NetworkElement = value;

                    if (internalObjectElement != null)
                    {
                        CreateSyncListener(internalObjectElement);
                    }
                }
            }
        }

#if UNITY_EDITOR
        public override object RawValue
        {
            get { return null; }
        }
#endif

        private User owner;
        public User Owner
        {
            get { return owner; }
            set
            {
                if (owner == null)
                {
                    owner = value;
                }
            }
        }

        public string ObjectType
        {
            get
            {
                return internalObjectElement != null ? internalObjectElement.GetObjectType().GetString() : null;
            }
        }

        public int OwnerId
        {
            get { return internalObjectElement != null ? internalObjectElement.GetOwnerID() : int.MaxValue; }
        }

        public SyncObject(string field)
            : base(field)
        {
            InitializePrimitives();
        }

        public SyncObject()
            : base(string.Empty)
        {
            InitializePrimitives();
        }

        public SyncPrimitive[] GetChildren()
        {
            return primitives.ToArray();
        }

        private void InitializePrimitives()
        {
            primitiveMap = new Dictionary<long, SyncPrimitive>();
            primitives = new List<SyncPrimitive>();

            // Scan the type of object this is a look for the SyncDataAttribute
            Type baseType = GetType();

#if USE_WINRT
            var typeFields = baseType.GetRuntimeFields();
#else
            var typeFields = baseType.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
#endif

            foreach (FieldInfo typeField in typeFields)
            {
                SyncDataAttribute attribute = null;

#if USE_WINRT
                attribute = typeField.GetCustomAttribute<SyncDataAttribute>(true);
#else
                object[] customAttributes = typeField.GetCustomAttributes(typeof(SyncDataAttribute), true);
                if (customAttributes.Length > 0)
                {
                    attribute = customAttributes[0] as SyncDataAttribute;
                }
#endif

                if (attribute != null)
                {
                    Type fieldType = typeField.FieldType;
                    string memberName = typeField.Name;

                    // Override the member name if provided
                    if (!string.IsNullOrEmpty(attribute.CustomFieldName))
                    {
                        memberName = attribute.CustomFieldName;
                    }

                    // Auto instantiate the primitive if it doesn't already exist
                    SyncPrimitive dataPrimitive = typeField.GetValue(this) as SyncPrimitive;
                    if (dataPrimitive == null)
                    {
                        try
                        {
                            // Constructors are not inherited, as per Section 1.6.7.1 of the C# Language Specification.
                            // This means that if a class subclasses Object or Primitive, they must either declare a constructor
                            // that takes the "memberName" property or use the default (parameter less constructor).

                            // First check if there is a constructor that takes the member name and if so call it
                            bool hasConstructor = fieldType.GetConstructor(new[] { typeof(string) }) != null;
                            if (hasConstructor)
                            {
                                dataPrimitive = (SyncPrimitive)Activator.CreateInstance(fieldType, memberName);
                            }
                            else
                            {
                                // Fallback on using the default constructor and manually assign the member name
                                dataPrimitive = (SyncPrimitive)Activator.CreateInstance(fieldType, null);
                                dataPrimitive.FieldName = memberName;
                            }

                            typeField.SetValue(this, dataPrimitive);
                        }
                        catch (Exception ex)
                        {
                            Debug.LogWarningFormat("Unable to create SyncPrimitive of type {0}.  Exception: {1}", memberName, ex);
                        }
                    }

                    if (dataPrimitive != null)
                    {
                        // Register the child
                        AddChild(dataPrimitive);
                    }
                }
            }
        }

        protected void AddChild(SyncPrimitive data)
        {
            if (data.HasNetworkElement)
            {
                long guid = data.Guid;
                Assert.AreNotEqual(SharingClient.kInvalidXGuid, guid, "A primitive GUID should never be invalid if it is networked.");
                primitiveMap.Add(guid, data);
            }

            if (!primitives.Contains(data))
            {
                primitives.Add(data);
            }
        }

        protected void RemoveChild(SyncPrimitive data)
        {
            // Manually remove from maps
            if (primitives.Remove(data) && data.HasNetworkElement)
            {
                primitiveMap.Remove(data.NetworkElement.GetGUID());

                // Object has been removed internally, notify network
                ObjectElement parentElement = ObjectElement.Cast(data.NetworkElement.GetParent());
                if (parentElement != null)
                {
                    parentElement.RemoveElement(data.NetworkElement);
                }
            }
        }

        protected virtual void OnElementAdded(Element element)
        {
            // Find the existing element.
            bool primitiveDataChanged = false;
            for (int i = 0; i < primitives.Count; i++)
            {
                if (primitives[i].XStringFieldName.IsEqual(element.GetName()))
                {
                    // Found it, register the element so it knows where to pull data from
                    primitives[i].AddFromRemote(element);

                    // Update the internal map
                    long guid = element.GetGUID();
                    primitiveMap[guid] = primitives[i];
                    primitiveDataChanged = true;
                    break;
                }
            }

            if (primitiveDataChanged)
            {
                // If there are no more primitives waiting to be added, finish the initialization
                if (primitiveMap.Count == primitives.Count)
                {
                    if (InitializationComplete != null)
                    {
                        InitializationComplete(this);
                    }
                }
            }
        }

        protected virtual void OnElementDeleted(Element element)
        {
            // If the child exists, then remove it.
            long guid = element.GetGUID();
            if (primitiveMap.ContainsKey(guid))
            {
                RemoveChild(primitiveMap[guid]);
            }
        }

        protected virtual void OnBoolElementChanged(long elementID, bool newValue)
        {
            if (primitiveMap.ContainsKey(elementID))
            {
                SyncPrimitive primitive = primitiveMap[elementID];
                primitive.UpdateFromRemote(newValue);
                NotifyPrimitiveChanged(primitive);
            }
            else
            {
                LogUnknownElement(elementID.ToString(), newValue.ToString(), typeof(bool));
            }
        }

        protected virtual void OnIntElementChanged(long elementID, int newValue)
        {
            if (primitiveMap.ContainsKey(elementID))
            {
                SyncPrimitive primitive = primitiveMap[elementID];
                primitive.UpdateFromRemote(newValue);
                NotifyPrimitiveChanged(primitive);
            }
            else
            {
                LogUnknownElement(elementID.ToString(), newValue.ToString(), typeof(int));
            }
        }

        protected virtual void OnLongElementChanged(long elementID, long newValue)
        {
            if (primitiveMap.ContainsKey(elementID))
            {
                SyncPrimitive primitive = primitiveMap[elementID];
                primitive.UpdateFromRemote(newValue);
                NotifyPrimitiveChanged(primitive);
            }
            else
            {
                LogUnknownElement(elementID.ToString(), newValue.ToString(), typeof(long));
            }
        }

        protected virtual void OnFloatElementChanged(long elementID, float newValue)
        {
            if (primitiveMap.ContainsKey(elementID))
            {
                SyncPrimitive primitive = primitiveMap[elementID];
                primitive.UpdateFromRemote(newValue);
                NotifyPrimitiveChanged(primitive);
            }
            else
            {
                LogUnknownElement(elementID.ToString(), newValue.ToString(CultureInfo.InvariantCulture), typeof(float));
            }
        }

        protected virtual void OnDoubleElementChanged(long elementID, double newValue)
        {
            if (primitiveMap.ContainsKey(elementID))
            {
                SyncPrimitive primitive = primitiveMap[elementID];
                primitive.UpdateFromRemote(newValue);
                NotifyPrimitiveChanged(primitive);
            }
            else
            {
                LogUnknownElement(elementID.ToString(), newValue.ToString(CultureInfo.InvariantCulture), typeof(double));
            }
        }

        protected virtual void OnStringElementChanged(long elementID, XString newValue)
        {
            if (primitiveMap.ContainsKey(elementID))
            {
                SyncPrimitive primitive = primitiveMap[elementID];
                primitive.UpdateFromRemote(newValue);
                NotifyPrimitiveChanged(primitive);
            }
            else
            {
                LogUnknownElement(elementID.ToString(), newValue.GetString(), typeof(string));
            }
        }

        private void LogUnknownElement(string elementName, string elementValue, Type elementType)
        {
            Debug.LogWarningFormat("Error: Trying to update an unknown child element!  Discarding update.  Type: {0}, Value: {1}, Id: {2}", elementType, elementValue, elementName);
        }

        protected virtual void NotifyPrimitiveChanged(SyncPrimitive primitive)
        {
            ObjectChanged.RaiseEvent(this);
        }

        private void CreateSyncListener(ObjectElement element)
        {
            // Create a listener for this
            syncListener = new ObjectElementAdapter();
            syncListener.ElementAddedEvent += OnElementAdded;
            syncListener.ElementDeletedEvent += OnElementDeleted;
            syncListener.BoolChangedEvent += OnBoolElementChanged;
            syncListener.IntChangedEvent += OnIntElementChanged;
            syncListener.LongChangedEvent += OnLongElementChanged;
            syncListener.FloatChangedEvent += OnFloatElementChanged;
            syncListener.DoubleChangedEvent += OnDoubleElementChanged;
            syncListener.StringChangedEvent += OnStringElementChanged;
            element.AddListener(syncListener);
        }

        #region From SyncPrimitive

        public override void InitializeLocal(ObjectElement parentElement)
        {
            // Auto create element if needed
            if (Element == null)
            {
                Element = parentElement.CreateObjectElement(XStringFieldName, GetType().FullName, Owner);
                NetworkElement = Element;
            }

            // Initialize all primitives
            for (int i = 0; i < primitives.Count; i++)
            {
                SyncPrimitive data = primitives[i];
                data.InitializeLocal(Element);
                primitiveMap[data.Guid] = data;
            }

            // Complete the initialization
            if (InitializationComplete != null)
            {
                InitializationComplete(this);
            }
        }

        public override void AddFromRemote(Element remoteElement)
        {
            Element = ObjectElement.Cast(remoteElement);
            NetworkElement = remoteElement;
        }

        #endregion //From SyncPrimitive
    }
}