protected override Scene ImportCore(Stream source, string fileName)
{
return(source is FileStream fileStream
? SceneUtilities.Import(fileStream.Name)
: throw new ArgumentException("Assimp scene can only be imported from a file stream",
nameof(source)));
}
public Enumerator(Scene scene)
{
if (scene.IsValid() == false)
{
throw new ArgumentException($"{nameof(scene)} is not valid!");
}
if (Application.isPlaying == false && scene.isLoaded == false)
{
throw new ArgumentException("The scene is not loaded.");
}
_index = -1;
_internalList = ObjectListPool.Rent();
if (scene.rootCount == 0)
{
return;
}
if (_internalList.Capacity < scene.rootCount)
{
_internalList.Capacity = scene.rootCount;
}
SceneUtilities.GetRootGameObjects(scene.handle, _internalList);
}
/// <summary>
/// Get user profile response
/// </summary>
/// <param name="result">Result of get user profile.</param>
private void OnGetUserProfile(Result <UserProfile> result)
{
if (result.IsError)
{
if (result.Error.Code != ErrorCode.UserProfileNotFound)
{
Tools.Log(_textInfo, "Failed to get user profile.", result.Error);
}
// IF user doesn't have any profile, we'll create a default empty user profile
// so the user can update it any time
else
{
Tools.Log(_textInfo, "Default user profile created.");
CreateUserProfileRequest userProfileRequest = new CreateUserProfileRequest {
language = ""
};
userProfiles.CreateUserProfile(userProfileRequest, createResult => { });
}
}
else
{
Tools.Log(_textInfo, "User profile obtained.");
AssignUserProfileToUI(result.Value);
}
}
protected override void ExportCore(Scene obj, Stream destination, string fileName)
{
if (destination is FileStream fileStream)
{
SceneUtilities.Export(obj, fileStream.Name);
}
else
{
throw new ArgumentException("AssimpSceneFormatModule can only export to FileStream", nameof(destination));
}
}
protected override Scene ImportCore(Stream source, string fileName)
{
if (source is FileStream fileStream)
{
return(SceneUtilities.Import(fileStream.Name));
}
else
{
throw new ArgumentException("AssimpSceneFormatModule can only import from FileStream", nameof(source));
}
}
/// <summary>
/// Login with device identifier.
/// </summary>
/// <param name="result">Result of the login.</param>
void OnLoginWithDeviceId(Result result)
{
if (!result.IsError)
{
Tools.Log(_textInfo, "Logging you in...");
SceneManager.LoadScene(SceneMainMenuName);
}
else
{
Tools.Log(_textInfo, "Failed to login anonymously.", result.Error);
}
}
/// <summary>
/// Login with email and password.
/// </summary>
/// <param name="result">Result of the login.</param>
void OnLoginWithUserName(Result result)
{
if (!result.IsError)
{
Tools.Log(_textInfo, "Success!");
SceneManager.LoadScene(SceneMainMenuName);
}
else
{
Tools.Log(_textInfo, "Failed to login with username and password.", result.Error);
}
}
public void GetParticipantsOfRoom_EmptyParticipants_ReturnEmpty()
{
// arrange
var rooms = new SynchronizedRooms(ImmutableList <Room> .Empty, "d",
ImmutableDictionary <string, string> .Empty);
// act
var result = SceneUtilities.GetParticipantsOfRoom(rooms, "test");
// assert
Assert.Empty(result);
}
/// <summary>
/// Account upgrade response.
/// </summary>
/// <param name="result">Result of the account upgrade action.</param>
void OnAccountUpgraded(Result <UserData> result)
{
if (!result.IsError)
{
Tools.Log(_textInfo, "Success upgrade account with email.");
user.GetData(OnGetUserData);
}
else
{
Tools.Log(_textInfo, "Failed to upgrade account with email.", result.Error);
}
}
/// <summary>
/// Update user profile response.
/// </summary>
/// <param name="result">Result of update user profile.</param>
private void OnUpdateUserProfile(Result <UserProfile> result)
{
if (result.IsError)
{
Tools.Log(_textInfo, "Failed to update user profile.", result.Error);
}
else
{
Tools.Log(_textInfo, "Success update your profile.");
AssignUserProfileToUI(result.Value);
}
}
protected override void ExportCore(Scene model, Stream destination, string fileName)
{
if (destination is FileStream fileStream)
{
SceneUtilities.Export(model, fileStream.Name);
}
else
{
throw new ArgumentException("Assimp scene can only be exported to file stream",
nameof(destination));
}
}
public void ParticipantsOfRoomChanged_PreviousValueNull_ReturnTrue()
{
// arrange
var current = new SynchronizedRooms(ImmutableList <Room> .Empty, "default",
ImmutableDictionary <string, string> .Empty);
SynchronizedRooms?previous = null;
// act
var result = SceneUtilities.ParticipantsOfRoomChanged("room1", current, previous);
// assert
Assert.True(result);
}
public async Task Handle(SynchronizedObjectUpdatedNotification notification,
CancellationToken cancellationToken)
{
if (notification.Value is SynchronizedScene newSyncScene)
{
if (!SceneUtilities.HasSceneStackChanged(newSyncScene, notification.PreviousValue as SynchronizedScene))
{
return;
}
await _mediator.Send(new UpdateParticipantsPermissionsRequest(notification.Participants));
}
}
public async ValueTask <SceneUpdate> IsUpdateRequired(string conferenceId, string roomId,
object synchronizedObject, object?previousValue)
{
if (synchronizedObject is SynchronizedRooms rooms)
{
if (SceneUtilities.ParticipantsOfRoomChanged(roomId, rooms, previousValue as SynchronizedRooms))
{
return(SceneUpdate.AvailableScenesChanged);
}
}
return(SceneUpdate.NotRequired);
}
public void HasSceneStackChanged_PreviousNull_ReturnTrue()
{
// arrange
var current = new SynchronizedScene(AutonomousScene.Instance, null, ImmutableList <IScene> .Empty,
ImmutableList <IScene> .Empty);
SynchronizedScene?previous = null;
// act
var result = SceneUtilities.HasSceneStackChanged(current, previous);
// assert
Assert.True(result);
}
public void HasSceneStackChanged_NotChanged_ReturnFalse()
{
// arrange
var current = new SynchronizedScene(AutonomousScene.Instance, null, ImmutableList <IScene> .Empty,
new IScene[] { AutonomousScene.Instance, GridScene.Instance });
var previous = new SynchronizedScene(GridScene.Instance, null, ImmutableList <IScene> .Empty,
new IScene[] { AutonomousScene.Instance, GridScene.Instance });
// act
var result = SceneUtilities.HasSceneStackChanged(current, previous);
// assert
Assert.False(result);
}
public void ParticipantsOfRoomChanged_SomeChangesInOtherRooms_ReturnFalse()
{
// arrange
var current = new SynchronizedRooms(ImmutableList <Room> .Empty, "default",
ImmutableDictionary <string, string> .Empty);
var previous = new SynchronizedRooms(ImmutableList <Room> .Empty, "default",
new Dictionary <string, string> {
{ "p1", "room2" }
});
// act
var result = SceneUtilities.ParticipantsOfRoomChanged("room1", current, previous);
// assert
Assert.False(result);
}
public override async ValueTask <IEnumerable <IScene> > GetAvailableScenes(string conferenceId, string roomId,
IReadOnlyList <IScene> sceneStack)
{
var rooms = await _mediator.FetchSynchronizedObject <SynchronizedRooms>(conferenceId,
SynchronizedRooms.SyncObjId);
var mediaState =
await _mediator.FetchSynchronizedObject <SynchronizedMediaState>(conferenceId,
SynchronizedMediaState.SyncObjId);
var participantsInRoom = SceneUtilities.GetParticipantsOfRoom(rooms, roomId);
return(participantsInRoom
.Where(participantId => mediaState.Streams.TryGetValue(participantId, out var streams) &&
streams.Producers.ContainsKey(ProducerSource.Screen)).Select(participantId =>
new ScreenShareScene(participantId)));
}
public void GetParticipantsOfRoom_SomeParticipants_ReturnParticipants()
{
// arrange
var rooms = new SynchronizedRooms(ImmutableList <Room> .Empty, "d", new Dictionary <string, string>
{
{ "p1", "room1" },
{ "p2", "room1" },
{ "p3", "room2" },
{ "p4", "room4" },
});
// act
var result = SceneUtilities.GetParticipantsOfRoom(rooms, "room1");
// assert
AssertHelper.AssertScrambledEquals(new[] { "p1", "p2" }, result);
}
protected override async ValueTask <bool> InternalIsUpdateRequired(string conferenceId, string roomId,
object synchronizedObject, object?previousValue)
{
if (synchronizedObject is SynchronizedRooms rooms)
{
if (SceneUtilities.ParticipantsOfRoomChanged(roomId, rooms, previousValue as SynchronizedRooms))
{
return(true);
}
}
else if (synchronizedObject is SynchronizedMediaState)
{
return(true);
}
return(false);
}
/// <summary>
/// Get user entitlements response
/// </summary>
/// <param name="result"></param>
private void OnGetUserEntitlements(Result <PagedEntitlements> result)
{
if (!result.IsError)
{
Tools.Log(_textInfo, "Success getting user entitlements");
entitlementList.Add(result.Value);
generateEntitlement(pageNow);
if (result.Value.paging.next != null)
{
entitlements.GetUserEntitlements(entitlementList.Count, pageSize, OnGetUserEntitlements);
}
}
else
{
Tools.Log(_textInfo, "Failed to get user entitlements.", result.Error);
}
}
/// <summary>
/// Get player's data response.
/// </summary>
/// <param name="result">Get player's data result.</param>
void OnGetUserData(Result <UserData> result)
{
if (!result.IsError)
{
Tools.Log(_textInfo, "Success get user data.");
_inputFields.Email.text = result.Value.EmailAddress;
if (result.Value.EmailAddress.IsNullOrEmpty())
{
ShowUpgradeComponent();
}
else
{
HideUpgradeComponent();
}
}
else
{
Tools.Log(_textInfo, "Failed to get user data.", result.Error);
}
}
/// <summary>
/// When add email button clicked then upgrade email account.
/// </summary>
public void OnAddEmailClicked()
{
Tools.Log(_textInfo, "Upgrading your email...");
user.Upgrade(_inputFields.Email.text, _inputFields.Password.text, OnAccountUpgraded);
}
/// <summary>
/// Called when user press LoginWithUserName button.
/// </summary>
void OnLoginEmailClicked()
{
Tools.Log(_textInfo, "Logging you in...");
user.LoginWithUserName(_inputFieldEmail.text, _inputFieldPassword.text, OnLoginWithUserName);
}
/// <summary>
/// Called when user press anonymous login button.
/// </summary>
void OnLoginAnonymouslyClicked()
{
Tools.Log(_textInfo, "Logging you in...");
user.LoginWithDeviceId(OnLoginWithDeviceId);
}
