public UniqueGameObject placeMnemonic(string typeName)
{
Vector3 forward = InputTracking.GetLocalRotation(VRNode.CenterEye) * cam.transform.forward;
Vector3 spawnPos = cam.transform.position + forward * 2;
UniqueGameObject uniqueSpawn = null;
//GameObject mnemonic = new GameObject();
Object mnemonic = new Object();
bool result = mnemonicDict.TryGetValue(typeName, out mnemonic);
if (!result)
{
Debug.Log("Couldn't find mnemonic object of typename: " + typeName);
}
else
{
uidTracker++;
string uid = userID + " " + uidTracker.ToString();
if (!uidSet.Contains(uid))
{
GameObject spawn = (GameObject)Instantiate(mnemonic, spawnPos, Quaternion.identity) as GameObject;
uniqueSpawn = new UniqueGameObject(spawn, uid, palaceUserID, typeName);
spawnedObjects.Add(uniqueSpawn);
uidSet.Add(uid);
FirebaseHandler database = GetComponent <FirebaseHandler>();
database.writeUniqueGameObject(uniqueSpawn);
}
else
{
Debug.Log("uidTracker broken - uid already exists");
}
}
return(uniqueSpawn);
}
private void Awake()
{
name = "Firebase";
if (_instance)
{
Destroy(_instance.gameObject);
_instance = null;
}
else
{
System.Text.StringBuilder builder = new System.Text.StringBuilder();
builder.Append("Directivas: ");
#if LOCAL
builder.Append("Local");
#endif
#if FORCE_FIREBASE
builder.Append("Force Firebase");
#endif
#if FORCE_LOCAL_DATA
builder.Append("Force Local Data");
#endif
Debug.Log(builder.ToString());
}
DontDestroyOnLoad(gameObject);
FirebaseWrapper.UpdateStartGame();
_instance = this;
}
/* class functions */
// gets data from db List<Dic<string, object>> and sets it to private variable
private async void SetData()
{
// dummy text for user
messageHeader.Text = "Loading messages, please wait!";
// change mouse cursor to load
Mouse.OverrideCursor = Cursors.Wait;
try
{
FirebaseHandler fbh = new FirebaseHandler();
CollectionHandler collectionHandler = new CollectionHandler();
this.data = await fbh.GetCollection(collectionHandler.GetMessageCollection());
//release mouse cursor to normal
Mouse.OverrideCursor = null;
if (this.data[0] != null)
{
// insert messages to "DOM" or ui
this.InsertToDom(this.data[0]);
}
}
catch (Exception e)
{
messageHeader.Text = "Error occured: " + e.Message;
}
}
/// <summary>
/// Save button functionality.
/// Calls methods ValidatePost() and BuildData()
/// Asks user confirmation to validate saving or chance to back out.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void SaveNewPost(object sender, RoutedEventArgs e)
{
if (this.ValidatePost())
{
MessageBoxResult wannaInsert = MessageBox.Show("Are you sure you want to add post?", "Confirmation", MessageBoxButton.YesNo, MessageBoxImage.Question);
if (wannaInsert == MessageBoxResult.Yes)
{
CollectionHandler collectionHandler = new CollectionHandler();
FirebaseHandler firebaseHandler = new FirebaseHandler();
string[] response = await firebaseHandler.SaveToDb(this.BuildData(), collectionHandler.GetBlogCollection(localesDrobdown.Text));
if (response[0].Equals("200"))
{
_ = MessageBox.Show("Blog post added", "Info", MessageBoxButton.OK, MessageBoxImage.Information);
}
else
{
_ = MessageBox.Show(response[1], "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
else
{
_ = MessageBox.Show("Inserting cancelled!", "Info", MessageBoxButton.OK, MessageBoxImage.Information);
}
}
else
{
_ = MessageBox.Show("Some fields are empty", "Info", MessageBoxButton.OK, MessageBoxImage.Information);
}
}
// Handles click on save button in username selection screen
public void OnClickSaveUsername()
{
string username = usernameField.text;
FirebaseHandler.SaveUsername(username);
SceneManager.LoadSceneAsync("CharacterSelectionScreen");
}
// Start is called before the first frame update
void Start()
{
surfaceDetection = GetComponent <SurfaceDetection>();
caliperEventHandler = GetComponent <CaliperEventHandler>();
firebaseHandler = GetComponent <FirebaseHandler>();
placeButton.onClick.AddListener(PlaceButtonEvent);
resetButton.onClick.AddListener(ResetAnchor);
}
public override void Init()
{
if (_handler != null)
{
Destroy(_handler.gameObject);
//We take the newest handler in case there are other Monobehaviours referencing other objects in the scene.
}
_handler = FindObjectOfType <FirebaseHandler>();
DontDestroyOnLoad(_handler.gameObject);
}
public App()
{
InitializeComponent();
DependencyService.Register <MockDataStore>();
FirebaseHandler.ConfigureFirebase();
MainPage = new NavigationPage(new LogAndRegActivity());
_ = LoginAndNavigate();
}
void InitFirebase()
{
this.FirebaseHandler = new FirebaseHandler(this);
if (!this.FirebaseHandler.IsPlayServicesAvailable(out string ErrorString))
{
return;
}
this.FirebaseHandler.CreateNotificationChannel();
string Token = FirebaseInstanceId.Instance.Token;
Log.Debug(this.Tag, "InstanceID token: " + FirebaseInstanceId.Instance.Token);
}
private async Task <bool> AutoLogin(string _username, string _password)
{
try
{
string result = await FirebaseHandler.Login(_username, _password);
return(result.Equals("Logging In"));
}
catch (Exception)
{
return(false);
}
}
public static Task <DependencyStatus> CheckDependenciesAsync()
{
FirebaseApp.SetCheckDependenciesThread(-2);
FirebaseHandler.CreatePartialOnMainThread(FirebaseAppUtils.Instance);
FirebaseApp.InitializeAppUtilCallbacks();
return(Task.Run <DependencyStatus>(delegate
{
FirebaseApp.SetCheckDependenciesThread(Thread.CurrentThread.ManagedThreadId);
DependencyStatus result = FirebaseApp.CheckDependencies();
FirebaseApp.SetCheckDependenciesThread(-1);
return result;
}));
}
private async Task <bool> IsValidID()
{
ProfileData profile = await FirebaseHandler.GetProfile(et_idCard.Text);
if (profile.Password.Equals("") && profile.Active.Equals("yes"))
{
return(true);
}
else
{
return(false);
}
}
/*
* public UniqueGameObject removeMnemonic(string typeName)
* {
* GameObject spawn = GameObject.Instantiate(mnemonic, spawnPos, Quaternion.identity);
* uidTracker++;
* string uid = userID + " " + uidTracker.ToString();
* if (!uidSet.Contains(uid))
* {
* uniqueSpawn = new UniqueGameObject(spawn, uid, palaceUserID, typeName);
* spawnedObjects.Add(uniqueSpawn);
* uidSet.Add(uid);
* FirebaseHandler database = GetComponent<FirebaseHandler>();
* database.writeUniqueGameObject(uniqueSpawn);
* }
* else
* {
* Debug.Log("uidTracker broken - uid already exists");
* }
* }
* return uniqueSpawn;
* }*/
private void removeUniqueGameObject(GameObject gameObject)
{
foreach (UniqueGameObject cur in spawnedObjects)
{
if (cur.gameObject == gameObject)
{
uidSet.Remove(cur.uid);
spawnedObjects.Remove(cur);
FirebaseHandler database = GetComponent <FirebaseHandler>();
database.deleteUniqueGameObject(cur);
break;
}
}
}
private InstallRootCerts()
{
var <> __AnonType = FirebaseHandler.RunOnMainThread(() => new
{
Platform = Application.platform,
IsEditor = Application.isEditor,
InstallationRequired = InstallRootCerts.InstallationRequired
});
if (< > __AnonType.InstallationRequired && InstallRootCerts.IsCertBugPresent(< > __AnonType.Platform))
{
if (< > __AnonType.IsEditor)
{
Services.Logging.LogMessage(PlatformLogLevel.Info, "Using workaround for .NET 4.6 certificate bug.");
this._needsCertificateWorkaround = true;
}
/// <summary>method <c>ReadSeries</c> Reads series information from firestore. Sets cursor to wait and releases it after data is fetched</summary>
private async void ReadSeries()
{
Mouse.OverrideCursor = Cursors.Wait;
FirebaseHandler firebaseHandler = new FirebaseHandler();
List <Dictionary <string, object> > data = await firebaseHandler.GetCollection("series");
List <string> temp = new List <string>();
foreach (Dictionary <string, object> x in data)
{
x.TryGetValue("name", out object name);
temp.Add(name.ToString());
}
this.FillDropDown(seriesDropdown, temp.ToArray());
Mouse.OverrideCursor = null;
}
/// <summary>
/// Deletes message. Gets id to remove from input field.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void DeleteMessage(object sender, RoutedEventArgs e)
{
MessageBoxResult result = MessageBox.Show("Are you sure you want to delete?", "Deleting", MessageBoxButton.YesNo, MessageBoxImage.Question);
if (result == MessageBoxResult.Yes && idToDelete.Text.Length > 0)
{
FirebaseHandler firebaseHandler = new FirebaseHandler();
CollectionHandler collection = new CollectionHandler();
string locale = "";
int index = 0;
foreach (dataModel item in this.dataCollection)
{
if (item.id.Equals(idToDelete.Text))
{
locale = item.locale;
index = this.dataCollection.IndexOf(item);
}
}
if (locale.Equals("fi") || locale.Equals("en"))
{
string[] response = await firebaseHandler.DeleteFromDb(idToDelete.Text, collection.GetNewsCollection(locale));
if (response[0].Equals("200"))
{
this.dataCollection.RemoveAt(index);
_ = MessageBox.Show("Deleted succesfully", "Deleted", MessageBoxButton.OK, MessageBoxImage.Information);
}
else
{
_ = MessageBox.Show(response[1], "Error happened", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
else
{
_ = MessageBox.Show("Error cannot get locale from news delete. Are you sure id is valid?", "Error happened", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
else if (idToDelete.Text.Length == 0)
{
_ = MessageBox.Show("Id to delete cannot be empty!", "Id is empty", MessageBoxButton.OK, MessageBoxImage.Information);
}
else
{
_ = MessageBox.Show("Nothing deleted!", "Confirmation", MessageBoxButton.OK, MessageBoxImage.Information);
}
}
// remove button
private async void RemoveMessage(object sender, RoutedEventArgs e)
{
MessageBoxResult wannaRemove = MessageBox.Show("Are you sure you want to remove?", "Confirmation", MessageBoxButton.YesNo, MessageBoxImage.Question);
if (wannaRemove == MessageBoxResult.Yes)
{
// collection does get removed if empty, prevent that
if (this.data.Count > 1)
{
FirebaseHandler firebaseHandler = new FirebaseHandler();
CollectionHandler collectionH = new CollectionHandler();
string[] response = await firebaseHandler.DeleteFromDb(this.currentMessage, collectionH.GetMessageCollection());
if (response[0].Equals("200"))
{
int index = this.FindIndex(this.currentMessage);
try
{
this.data.RemoveAt(index);
this.InsertToDom(this.data[0]);
_ = MessageBox.Show("Document deleted!", "Information", MessageBoxButton.OK, MessageBoxImage.Information);
}
catch (Exception ed)
{
_ = MessageBox.Show(ed.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
//error from firebase
else
{
_ = MessageBox.Show(response[1], "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
// cannot remove only document
else
{
_ = MessageBox.Show("Nothing removed! Collection length must be at least one.", "Information", MessageBoxButton.OK, MessageBoxImage.Information);
}
}
// cancelled remove
else
{
_ = MessageBox.Show("Nothing removed!", "Information", MessageBoxButton.OK, MessageBoxImage.Information);
}
}
// Handles click on save button in character selection screen
public void OnClickSaveCharacter()
{
//If not loading from main menu (loading from username input)
if (!MenuScreenLoadParam.CharacterLoadFromMenu)
{
FirebaseHandler.SaveCharacter(spriteArr[characterIndex]);
FirebaseHandler.WriteNewUser();
SceneManager.LoadSceneAsync("Persistent");
}
else
{
FirebaseScript firebaseScript = FindObjectOfType <FirebaseScript>();
DataController dataController = FindObjectOfType <DataController>();
firebaseScript.UpdateUserChar("pipo-nekonin00" + (characterIndex + 1).ToString());
dataController.currentUser.chr = "pipo-nekonin00" + (characterIndex + 1).ToString();
SceneManager.LoadSceneAsync("MenuScreen");
}
}
public void addMnemonicFromMenu(string typeName, GameObject spawn)
{
uidTracker++;
string uid = userID + " " + uidTracker.ToString();
if (!uidSet.Contains(uid))
{
UniqueGameObject uniqueSpawn = new UniqueGameObject(spawn, uid, palaceUserID, typeName);
spawnedObjects.Add(uniqueSpawn);
uidSet.Add(uid);
FirebaseHandler database = GetComponent <FirebaseHandler>();
database.writeUniqueGameObject(uniqueSpawn);
}
else
{
Debug.Log("uidTracker broken - uid already exists");
}
}
public void getInitialAssets(bool isPoly)
{
polyDescription = isPoly;
FirebaseHandler firebaseHandler = FindObjectOfType <FirebaseHandler>();
m_cameraTransform = GameObject.FindWithTag("MainCamera").transform;
asset_id_name_list = new List <KeyValuePair <string, string> >();
asset_thumbnail_list = new List <KeyValuePair <string, Texture2D> >();
// list featured assets
if (isPoly)
{
PolyApi.ListAssets(PolyListAssetsRequest.Featured(), FeaturedAssetListCallback);
}
else
{
firebaseHandler.getElements(HandleFirebaseObjects);
}
}
private async Task loginTask()
{
string response = await FirebaseHandler.Login(et_idCard.Text, et_password.Text);
if (response.Equals("Logging In")) //Account is good
{
Console.WriteLine("Logging In");
if (chkRemember.IsChecked)
{
SaveAutoLogin().Wait();
}
await Navigation.PushAsync(new MainActivity());
}
else
{
validationText.Text = response;
}
}
/// <summary>
/// Loads news from firestore.
/// Controls mouse cursor to show loading. Raises exception if firebase fails.
/// </summary>
/// <exception cref="Exception">Errors in firebase</exception>
private async void GetData()
{
Mouse.OverrideCursor = Cursors.Wait;
try
{
FirebaseHandler fbh = new FirebaseHandler();
CollectionHandler collectionHandler = new CollectionHandler();
List <Dictionary <string, object> > list1 = await fbh.GetCollection(collectionHandler.GetNewsCollection("fi"));
List <Dictionary <string, object> > list2 = await fbh.GetCollection(collectionHandler.GetNewsCollection("en"));
this.news.AddRange(list1);
this.news.AddRange(list2);
Mouse.OverrideCursor = null;
this.FillDataCollection();
}
catch (Exception e)
{
_ = MessageBox.Show(e.Message, "There was an error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
// Sign in to Firebase
private void SignInFirebase(Credential credential)
{
auth = FirebaseAuth.DefaultInstance;
// Sign in to Firebase Authentication using credentials from providers
auth.SignInWithCredentialAsync(credential).ContinueWith(task =>
{
if (task.IsCanceled)
{
Debug.LogError("SignInWithCredentialAsync was canceled.");
return;
}
if (task.IsFaulted)
{
Debug.LogError("SignInWithCredentialAsync encountered an error: " + task.Exception);
return;
}
user = task.Result;
Debug.LogFormat("User signed in successfully: {0} ({1})", user.DisplayName, user.UserId);
// Check if user has registered before
bool registered = FirebaseHandler.CheckIfUserIsRegistered().Result;
// Registered user
if (registered)
{
Debug.Log("User has registered, proceed to home screen");
SceneManager.LoadSceneAsync("Persistent");
}
// New user
else
{
Debug.Log("User has not registered, proceed to username and character selection");
FirebaseHandler.CreateNewUser(user.UserId);
SceneManager.LoadSceneAsync("InputUsernameScreen");
}
});
}
/// <summary>
/// Saves new news to database
/// Controls mouse cursor, sets it to loading and when done to normal. TODO form validation
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void SaveToDb(object sender, RoutedEventArgs e)
{
Mouse.OverrideCursor = Cursors.Wait;
Dictionary <string, object> formData = new Dictionary <string, object>
{
{ "date", dateBox.Text },
{ "headline", headlineBox.Text },
{ "locale", localeBox.Text },
{ "message", messageBox.Text }
};
FirebaseHandler FH = new FirebaseHandler();
string[] result = await FH.SaveToDb(formData, this.collectionHandler.GetNewsCollection(formData["locale"].ToString()));
Mouse.OverrideCursor = null;
if (result[0].Equals("200"))
{
_ = MessageBox.Show(result[1], "Confirmation", MessageBoxButton.OK, MessageBoxImage.Information);
}
else
{
MessageBox.Show(result[1], "Confirmation", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public override string GetWriteablePath(IFirebaseAppPlatform app)
{
return(FirebaseHandler.RunOnMainThread <string>(() => Application.persistentDataPath));
}
private void Register()
{
_ = FirebaseHandler.Register(new ProfileData("yes", et_email.Text, et_idCard.Text, et_mobile.Text, et_password.Text));
}
private static FirebaseApp CreateAndTrack(FirebaseApp.CreateDelegate createDelegate, FirebaseApp existingProxy)
{
FirebaseApp.ThrowIfCheckDependenciesRunning();
FirebaseHandler.Create(FirebaseAppUtils.Instance);
object obj = FirebaseApp.nameToProxy;
FirebaseApp result2;
lock (obj)
{
FirebaseApp.InitializeAppUtilCallbacks();
HandleRef cPtr = new HandleRef(null, IntPtr.Zero);
FirebaseApp firebaseApp;
try
{
FirebaseApp.AppSetDefaultConfigPath(PlatformInformation.DefaultConfigLocation);
firebaseApp = createDelegate();
if (AppUtilPINVOKE.SWIGPendingException.Pending)
{
throw AppUtilPINVOKE.SWIGPendingException.Retrieve();
}
if (firebaseApp == null)
{
throw new InitializationException(InitResult.FailedMissingDependency, "App creation failed with an unknown error.");
}
cPtr = FirebaseApp.getCPtr(firebaseApp);
}
catch (ApplicationException ex)
{
FirebaseApp.OnAllAppsDestroyed();
string text = ex.Message;
InitResult result = InitResult.FailedMissingDependency;
int num = text.IndexOf(":");
if (num >= 0)
{
result = (InitResult)int.Parse(text.Substring(0, num));
text = text.Substring(num + 1);
}
if (text.IndexOf("Please verify the AAR") >= 0)
{
text = text + "\n" + ErrorMessages.DependencyNotFoundErrorMessage;
}
throw new InitializationException(result, text);
}
catch (Exception ex2)
{
FirebaseApp.OnAllAppsDestroyed();
throw ex2;
}
if (cPtr.Handle == IntPtr.Zero)
{
result2 = null;
}
else
{
WeakReference weakReference;
if (FirebaseApp.cPtrToProxy.TryGetValue(cPtr.Handle, out weakReference))
{
FirebaseApp firebaseApp2 = FirebaseApp.WeakReferenceGetTarget(weakReference) as FirebaseApp;
if (firebaseApp2 != null)
{
if (existingProxy != firebaseApp2)
{
FirebaseApp.LogMessage(LogLevel.Warning, string.Format("Detected multiple FirebaseApp proxies for {0}", existingProxy.Name));
existingProxy.Dispose();
}
result2 = firebaseApp2;
return(result2);
}
}
if (FirebaseApp.cPtrToProxy.Count == 0)
{
string text2 = "fire-" + PlatformInformation.RuntimeName;
FirebaseApp.RegisterLibraryInternal(text2, VersionInfo.SdkVersion);
FirebaseApp.RegisterLibraryInternal(text2 + "-ver", PlatformInformation.RuntimeVersion);
}
firebaseApp.name = firebaseApp.NameInternal;
firebaseApp.AddReference();
if (!FirebaseApp.installedCerts)
{
FirebaseApp.installedCerts = true;
Services.RootCerts.Install(firebaseApp.AppPlatform);
}
if (!FirebaseApp.crashlyticsInitializationAttempted)
{
FirebaseApp.crashlyticsInitializationAttempted = true;
FirebaseHandler.RunOnMainThread <bool>(() => FirebaseApp.InitializeCrashlyticsIfPresent());
}
result2 = firebaseApp;
}
}
return(result2);
}
private void InitFirebase()
{
FirebaseHandler.Init(this);
}
protected override void OnStart()
{
FirebaseHandler.ConfigureFirebase();
}
