private IPublisherClient CreatePublisher(UnityProject project, UnityUser user)
{
// This is the public name of the Source Project you want to export (it doesn't have to be unique).
string sourceName = $"{project.Name}_markers";
// This identifies the Source Project you want to export and must be unique and persistent over multiple publishing sessions.
string baseIdString = $"{project.ProjectId}_markers";
string sourceId;
using (MD5 md5 = MD5.Create())
{
byte[] hash = md5.ComputeHash(Encoding.Default.GetBytes(baseIdString));
sourceId = new Guid(hash).ToString();
}
var version = Regex.Replace(Application.version, "[^0-9.]", "");
//Create the publisher settings for the client
m_PublisherSettings = new PublisherSettings(project, user)
{
PluginName = Application.productName + " MarkerPublisher",
//TODO: Use Reflect DLL version
PluginVersion = Version.Parse(version),
LengthUnit = LengthUnit.Meters,
AxisInversion = AxisInversion.None
};
// Create a Publisher Client, that will allow us to publish data into the selected Unity Project.
return(Publisher.OpenClient(sourceName, sourceId, m_PublisherSettings, false));
}
public static void SetUser(UnityUser user, IUpdateDelegate updater, IProjectProvider client, PlayerStorage storage) // TODO Rename or move into a ProjectLister manager class
{
// ProjectLister
s_ProjectListerSettings = new ProjectListerSettings();
s_ProjectListerSettings.OnProjectsRefreshCompleted = new ProjectListerSettings.ProjectsEvents();
s_ProjectListerSettings.OnProjectsRefreshStarted = new UnityEvent();
s_ProjectListerSettings.OnProjectsRefreshCompleted.AddListener((projects) =>
{
projectsRefreshCompleted?.Invoke(projects);
});
s_ProjectLister = new ProjectsLister(s_ProjectListerSettings)
{
client = client
};
s_ProjectLister.SetUpdateDelegate(updater);
s_ProjectDeleterSettings = new ProjectDeleterSettings();
s_ProjectDeleterSettings.projectLocalDataDeleted += OnProjectLocalDataDeleted;
s_ProjectDeleterSettings.projectDeleteCanceled += OnProjectDeleteCanceled;
s_ProjectDeleterSettings.projectDeleteProgressChanged += OnProjectDeleteProgressChanged;
s_ProjectDeleter = new ProjectDeleter(s_ProjectDeleterSettings, storage)
{
client = client
};
s_ProjectDeleter.SetUpdateDelegate(updater);
s_ProjectDownloaderSettings = new ProjectDownloaderSettings();
s_ProjectDownloaderSettings.projectDataDownloaded += OnProjectDataDownloaded;
s_ProjectDownloaderSettings.projectDownloadCanceled += OnProjectDownloadCanceled;
s_ProjectDownloaderSettings.projectDownloadProgressChanged += OnProjectDownloadProgressChanged;
s_ProjectDownloader = new ProjectDownloader(s_ProjectDownloaderSettings, updater, user, storage);
}
internal void OnCompletedUnityUserTask(Task <UnityUser> task)
{
if (task.IsFaulted)
{
Debug.LogError($"Get User Info failed: {task.Exception}");
authenticationFailed?.Invoke(task.Exception.ToString());
}
else
{
var user = task.Result;
if (DateTime.UtcNow > user.SessionExpiry - s_SessionExpiryThreshold &&
Application.internetReachability != NetworkReachability.NotReachable)
{
Debug.LogWarning($"User token about to expire, force login");
authenticationFailed?.Invoke("Token expired");
}
else
{
m_User = user;
userLoggedIn?.Invoke(m_User);
}
}
m_UnityUserTask = null;
}
public void InstantiateAndStart(ActorSystemSetup actorSystemSetup,
IExposedPropertyTable resolver = null,
UnityProject unityProject = null,
UnityUser unityUser = null)
{
Hook.InstantiateAndStart(actorSystemSetup, resolver, unityProject, unityUser);
}
public void OpenProject(Project project, UnityUser user, AccessToken accessToken, bool isRestarting, Action <BridgeActor.Proxy> settingsOverrideAction)
{
if (isRestarting)
{
Restart();
}
else
{
Instantiate(project, user, accessToken,
bridge =>
{
var viewerBridge = Hook.GetActor <ViewerBridgeActor>();
ViewerBridge = new ViewerBridgeActor.Proxy(viewerBridge);
settingsOverrideAction(bridge);
},
runner =>
{
var bridge = runner.GetActor <ViewerBridgeActor>();
bridge.SetActorRunner(Hook.Systems.ActorRunner);
});
}
ActorSystemStarting?.Invoke(Bridge, isRestarting);
StartActorSystem();
ActorSystemStarted?.Invoke(Bridge);
StreamingStarting?.Invoke(Bridge);
Bridge.SendUpdateManifests();
StreamingStarted?.Invoke(Bridge);
}
public void UpdateProject(UnityProject project, UnityUser user)
{
if (m_PublisherClient != null)
{
m_PublisherClient.CloseAndWait();
}
try
{
m_PublisherClient = CreatePublisher(project, user);
}
catch (Exception e)
{
Debug.LogError(e);
m_PublisherClient?.CloseAndWait();
}
if (m_PublisherClient == null)
{
Debug.LogError("Publisher failed to open");
throw new NullReferenceException("Publisher Missing");
}
if (!m_PublisherClient.IsTypeSendable <SyncMarker>())
{
Debug.LogError("SyncMarkers not supported");
throw new SyncModelNotSupportedException("SyncMarkers not supported by the project host");
}
}
public void AssignUserAndRegister(UnityUser relevantUser, int order, int totalNumIcons)
{
this.IconOrder = order;
this.IconCountTotal = totalNumIcons;
startDelay += order * OrderOffset;
startEvent.id = relevantUser.Id.ToString();
CallRegisterForAnimation();
}
public void OnUserLogin(UnityUser user)
{
if (user != null)
{
m_exceptionExtraInfo.userId = user.UserId;
onExceptionExtraInfoChanged?.Invoke(JsonUtility.ToJson(m_exceptionExtraInfo));
}
}
private void InstantiateRelevantUser(Transform parent, UnityUser user, int scoreDelta, int order = 1, int total = 1)
{
var relUser = Instantiate(PlayerIconPrefab, parent);
relUser.transform.localScale = new Vector3(1f, 1f, 1f);
relUser.transform.localPosition = Vector3.zero;
//relUser.GetComponent<RelevantUserPopulator>().Populate(user, true, scoreDelta, order, total);
}
public ProjectDownloader(ProjectDownloaderSettings settings, IUpdateDelegate updateDelegate, UnityUser user, PlayerStorage playerStorage)
{
m_Settings = settings;
m_PlayerStorage = playerStorage;
m_UpdateDelegate = updateDelegate;
m_User = user;
SetUpdateDelegate(updateDelegate);
}
private void InstantiateRelevantUser(UnityUser user, bool showName = true, int scoreDelta = 0, int order = 1, int total = 1)
{
GameObject playerIconPrefab = PrefabLookup.Singleton.Mapping[PrefabLookup.PrefabType.UserIcon];
var relUser = Instantiate(playerIconPrefab, DropZone.transform);
relUser.transform.localScale = new Vector3(1f, 1f, 1f);
relUser.transform.localPosition = Vector3.zero;
relUser.GetComponent <RelevantUserPopulator>().Populate(user, showName, scoreDelta, order, total);
}
public ReflectClient(IUpdateDelegate updateDelegate, UnityUser user, PlayerStorage storage, UnityProject project)
{
m_Project = project;
m_User = user;
m_Storage = storage;
InitializeProjectClientListener();
updateDelegate.update += OnUpdate;
}
public static void InstantiateAndStart(this ReflectBootstrapper reflectBootstrapper,
ActorSystemSetup actorSystemSetup,
IExposedPropertyTable resolver = null,
UnityProject unityProject = null,
UnityUser unityUser = null)
{
var actorRunnerProxy = reflectBootstrapper.systems.ActorRunner;
actorRunnerProxy.Instantiate(actorSystemSetup, unityProject, resolver, unityUser);
actorRunnerProxy.StartActorSystem();
}
public SessionState(LoginState loggedState, UnityUser user, ProjectRoom[] rooms)
{
this.loggedState = loggedState;
this.user = user;
this.rooms = rooms;
userIdentity = default;
linkShareLoggedOut = false;
linkSharePermission = LinkPermission.Private;
isInPrivateMode = false;
collaborationState = CollaborationState.Disconnected;
linkSharedProjectRoom = default;
}
public void SetUser(UnityUser user)
{
if (user == null || string.IsNullOrEmpty(user.UserId))
{
Debug.LogError("Invalid User");
}
// Client
m_AuthClient = new AuthClient(user);
ReflectProjectsManager.Init(user, this, m_AuthClient);
}
public void Populate(UnityUser user, bool showName, int scoreDelta = 0, int order = 1, int total = 1)
{
gameObject.GetComponent <MoveUserIconAnimation>().AssignUserAndRegister(user, order, total);
gameObject.GetComponent <ShowScoreDeltaAnimation>().AssignUserAndRegister(scoreDelta);
TargetLocation.sprite = user.SelfPortraitSprite;
Colorizer.UpdateValue(new List <Guid>()
{
user.Id
});
DisplayName.text = user.DisplayName;
DisplayName.transform.parent.gameObject.SetActive(showName);
}
private void LoginToPublisher()
{
//Create a local sync service project.
string projectStr = File.ReadAllText($"{importPath}/project.json");
UnityProjectData projectData = JsonUtility.FromJson <UnityProjectData>(projectStr);
UnityProject project = new UnityProject(projectData.ProjectId, projectData.ProjectName);
//Create a Unity User
string userStr = File.ReadAllText($"{importPath}/user.json");
UnityUserData userData = JsonUtility.FromJson <UnityUserData>(userStr);
UnityUser user = new UnityUser(userData.AccessToken, userData.DisplayName, userData.UserId);
publisher = new MarkerPublisher();
publisher.UpdateProject(project, user);
}
public void SetUser(UnityUser user)
{
if (user == null || string.IsNullOrEmpty(user.UserId))
{
Debug.LogError("Invalid User");
}
// Storage
var storage = new PlayerStorage(ProjectServer.ProjectDataPath, true, false);
// Client
m_AuthClient = new AuthClient(user, storage);
ReflectPipelineFactory.SetUser(user, this, m_AuthClient, storage);
}
public UISessionStateData(LoginState loggedState, UnityUser user, ProjectRoom[] rooms)
{
this.loggedState = loggedState;
this.user = user;
this.rooms = rooms.Cast <IProjectRoom>().ToArray();
projectListState = loggedState == LoginState.LoggedIn ? ProjectListState.AwaitingUserData : ProjectListState.AwaitingUser;
userIdentity = new UserIdentity();
linkShareLoggedOut = false;
isOpenWithLinkSharing = false;
linkSharePermission = LinkPermission.Private;
isInPrivateMode = false;
cachedLinkToken = string.Empty;
collaborationState = CollaborationState.Disconnected;
linkSharedProjectRoom = default;
networkReachability = default;
projectServerConnection = true;
}
public void UpdateProject(UnityProject currentProject, UnityUser user)
{
m_MarkerController.LoadingComplete = false;
try
{
m_SyncMarkerStore?.UpdateProject(currentProject, user);
}
catch (SyncModelNotSupportedException ex)
{
m_MarkerController.UnsupportedMessage = "QR Markers unsupported by Host.";
Debug.LogError($"SyncMarkers not supported by the server: {ex}");
}
catch (Exception ex)
{
m_MarkerController.UnsupportedMessage = $"QR Markers failed to connect to Host: {ex.Message}";
Debug.LogError($"Exception thrown creating publisher client: {ex}");
}
}
public static void Init(UnityUser user, IUpdateDelegate updater, IProjectProvider client) // TODO Rename or move into a ProjectLister manager class
{
if (s_ProjectLister != null || s_ProjectsManager != null)
{
Dispose();
}
// ProjectLister
s_ProjectLister = new ProjectsLister(client);
s_ProjectLister.projectListingCompleted += OnProjectListingCompleted;
s_ProjectLister.projectListingException += OnProjectListingException;
s_ProjectLister.SetUpdateDelegate(updater);
s_ProjectsManager = new ProjectsManager(updater, user, Storage.main);
s_ProjectsManager.projectStatusChanged += OnProjectStatusChanged;
s_ProjectsManager.projectDownloadProgressChanged += OnProjectDownloadProgressChanged;
s_ProjectsManager.projectDeleteProgressChanged += OnProjectDeleteProgressChanged;
}
public void UpdateProject(UnityProject currentProject, UnityUser user)
{
if (currentProject.ProjectId == m_CurrentProject && currentProject.Host.ServerId == m_CurrentServer)
{
return;
}
m_Markers.Clear();
OnUpdated?.Invoke(new Delta <Marker>());
if (currentProject == (UnityProject)Project.Empty)
{
m_CurrentProject = m_CurrentServer = null;
m_Publisher.Disconnect();
return;
}
m_CurrentProject = currentProject.ProjectId;
m_CurrentServer = currentProject.Host.ServerId;
m_Publisher.UpdateProject(currentProject, user);
}
// This method is called from the LoginManager component inside the sample Scene.
// This is the same LoginManager used in the Reflect Viewers.
// While in the Editor, the user is the current Unity account logged into the Unity Editor.
// Once logged in, we can list available projects by using a ProjectLister with an AuthClient.
public void OnUserLoggedIn(UnityUser user)
{
m_State = State.ListingProjects;
// A storage is required to specify where data are saved and cached
m_Storage = new PlayerStorage(Path.Combine(Application.dataPath, ".ReflectSamplesTemp"), false, false);
// Create a Authentication client from the current Unity user
m_AuthClient = new AuthClient(user, m_Storage);
var projectListerSettings = new ProjectListerSettings
{
OnProjectsRefreshCompleted = new ProjectListerSettings.ProjectsEvents(),
OnProjectsRefreshStarted = new UnityEvent()
};
projectListerSettings.OnProjectsRefreshCompleted.AddListener((projects) =>
{
// This is the callback for when all projects are done listing.
// For this sample, we populate a list that will be displayed as UI in the OnGUI method.
m_State = State.ProjectListed;
m_AvailableProjects = projects;
});
// Create a ProjectLister to enumerate all available projects in the cloud for this user
m_ProjectsLister = new ProjectsLister(projectListerSettings)
{
client = m_AuthClient
};
// Since ProjectLister runs in another thread, make sure to set the UpdateDelegate to be able to collect received data into the main thread.
m_ProjectsLister.SetUpdateDelegate(this);
// Start the ProjectLister thread. OnProjectsRefreshCompleted callback will be called when all projects are done listing.
m_ProjectsLister.Run();
}
void OnUserChanged(UnityUser newData)
{
m_CurrentUserId = newData.UserId;
}
public AuthClient(UnityUser user, PlayerStorage storage)
{
this.user = user;
this.storage = storage;
}
public SessionState(LoginState loggedState, UnityUser user, Project[] projects)
{
this.loggedState = loggedState;
this.user = user;
this.projects = projects;
}
