/// <summary> /// Logs the user in to the Realm Object Server. /// </summary> /// <param name="credentials">The credentials to use for authentication.</param> /// <param name="serverUri">The URI of the server that the user is authenticated against.</param> /// <returns>An awaitable Task, that, upon completion, contains the logged in user.</returns> public static async Task <User> LoginAsync(Credentials credentials, Uri serverUri) { Argument.NotNull(credentials, nameof(credentials)); Argument.NotNull(serverUri, nameof(serverUri)); Argument.Ensure(serverUri.Scheme.StartsWith("http"), "Unexpected protocol for login url. Expected http:// or https://.", nameof(serverUri)); SharedRealmHandleExtensions.DoInitialFileSystemConfiguration(); if (credentials.IdentityProvider == Credentials.Provider.AdminToken) { return(new User(SyncUserHandle.GetAdminTokenUser(serverUri.AbsoluteUri, credentials.Token))); } if (credentials.IdentityProvider == Credentials.Provider.CustomRefreshToken) { var userId = (string)credentials.UserInfo[Credentials.Keys.Identity]; var isAdmin = (bool)credentials.UserInfo[Credentials.Keys.IsAdmin]; return(new User(SyncUserHandle.GetSyncUser(userId, serverUri.AbsoluteUri, credentials.Token, isAdmin))); } var result = await AuthenticationHelper.LoginAsync(credentials, serverUri); var handle = SyncUserHandle.GetSyncUser(result.UserId, serverUri.AbsoluteUri, result.RefreshToken, result.IsAdmin); return(new User(handle)); }
/// <summary> /// Initializes a new instance of the <see cref="SyncConfiguration"/> class. /// </summary> /// <param name="user"> /// A valid <see cref="User"/>. If not provided, the currently logged-in user will be used. /// </param> /// <param name="serverUri"> /// A unique <see cref="Uri"/> that identifies the Realm. In URIs, <c>~</c> can be used as a placeholder for a user Id. /// If a relative Uri is provided, it will be resolved using the user's <see cref="ServerUri"/> as baseUri. /// If <c>null</c> is passed, a Uri will be constructed from the user's <see cref="ServerUri"/>, combined with /// <c>/default</c> and <see cref="IsPartial"/> will be set to <c>true</c>. /// </param> /// <param name="optionalPath"> /// Path to the realm, must be a valid full path for the current platform, relative subdirectory, or just filename. /// </param> public SyncConfiguration(User user = null, Uri serverUri = null, string optionalPath = null) { Argument.Ensure(user != null || User.AllLoggedIn.Length == 1, "The user must be explicitly specified when the number of logged-in users is not 1.", nameof(user)); User = user ?? User.Current; if (serverUri == null) { // Using default realm IsPartial = true; ServerUri = User.GetUriForRealm("/default"); } else if (!serverUri.IsAbsoluteUri) { ServerUri = User.GetUriForRealm(serverUri); } else { Argument.Ensure(serverUri.Scheme.StartsWith("realm"), "Unexpected protocol for server url. Expected realm:// or realms://.", nameof(serverUri)); ServerUri = serverUri; } DatabasePath = GetPathToRealm(optionalPath ?? SharedRealmHandleExtensions.GetRealmPath(User, ServerUri)); }
internal override async Task <Realm> CreateRealmAsync(RealmSchema schema) { var session = new Session(SharedRealmHandleExtensions.GetSession(DatabasePath, ToNative(), EncryptionKey)); await session.WaitForDownloadAsync(); return(CreateRealm(schema)); }
/// <summary> /// Configures user persistence. If you need to call this, be sure to do so before accessing any other Realm API. /// </summary> /// <param name="mode">The persistence mode.</param> /// <param name="encryptionKey">The key to encrypt the persistent user store with.</param> /// <param name="resetOnError">If set to <c>true</c> reset the persistent user store on error.</param> /// <remarks> /// Users are persisted in a realm file within the application's sandbox. /// <para> /// By default <see cref="User"/> objects are persisted and are additionally protected with an encryption key stored /// in the iOS Keychain when running on an iOS device (but not on a Simulator). /// On Android users are persisted in plaintext, because the AndroidKeyStore API is only supported on API level 18 and up. /// You might want to provide your own encryption key on Android or disable persistence for security reasons. /// </para> /// </remarks> public static void ConfigurePersistence(UserPersistenceMode mode, byte[] encryptionKey = null, bool resetOnError = false) { if (mode == UserPersistenceMode.Encrypted && encryptionKey != null && encryptionKey.Length != 64) { throw new ArgumentException("The encryption key must be 64 bytes long", nameof(encryptionKey)); } SharedRealmHandleExtensions.ConfigureFileSystem(mode, encryptionKey, resetOnError); }
/// <summary> /// Initializes a new instance of the <see cref="SyncConfiguration"/> class. /// </summary> /// <param name="user">A valid <see cref="User"/>.</param> /// <param name="serverUri"> /// A unique <see cref="Uri"/> that identifies the Realm. In URIs, <c>~</c> can be used as a placeholder for a user Id. /// </param> /// <param name="optionalPath"> /// Path to the realm, must be a valid full path for the current platform, relative subdirectory, or just filename. /// </param> public SyncConfiguration(User user, Uri serverUri, string optionalPath = null) : base(optionalPath ?? SharedRealmHandleExtensions.GetRealmPath(user, serverUri)) { Argument.NotNull(user, nameof(user)); Argument.NotNull(serverUri, nameof(serverUri)); Argument.Ensure(serverUri.Scheme.StartsWith("realm"), "Unexpected protocol for server url. Expected realm:// or realms://.", nameof(serverUri)); User = user ?? throw new ArgumentNullException(nameof(user)); ServerUri = serverUri ?? throw new ArgumentNullException(nameof(serverUri)); }
/// <summary> /// Gets a logged in user with a specified identity. /// </summary> /// <returns>A user instance if a logged in user with that id exists, <c>null</c> otherwise.</returns> /// <param name="identity">The identity of the user.</param> /// <param name="serverUri">The URI of the server that the user is authenticated against.</param> public static User GetLoggedInUser(string identity, Uri serverUri) { SharedRealmHandleExtensions.DoInitialFileSystemConfiguration(); if (SyncUserHandle.TryGetLoggedInUser(identity, serverUri.AbsoluteUri, out var userHandle)) { return(new User(userHandle)); } return(null); }
internal override Realm CreateRealm(RealmSchema schema) { var configuration = new Realms.Native.Configuration { Path = DatabasePath, schema_version = SchemaVersion }; var srHandle = SharedRealmHandleExtensions.OpenWithSync(configuration, ToNative(), schema, EncryptionKey); return(new Realm(srHandle, this, schema)); }
/// <summary> /// Gets a logged in user with a specified identity. /// </summary> /// <returns>A user instance if a logged in user with that id exists, <c>null</c> otherwise.</returns> /// <param name="identity">The identity of the user.</param> /// <param name="serverUrl">The URI of the server that the user is authenticated against.</param> public static User GetLoggedInUser(string identity, Uri serverUrl) { SharedRealmHandleExtensions.DoInitialFileSystemConfiguration(); var handle = SyncUserHandle.GetLoggedInUser(identity, serverUrl.AbsoluteUri); if (handle == null) { return(null); } return(new User(handle)); }
public static User GetLoggedInUser(string identity, Uri serverUri) { Argument.NotNull(identity, nameof(identity)); Argument.NotNull(serverUri, nameof(serverUri)); SharedRealmHandleExtensions.DoInitialMetadataConfiguration(); if (SyncUserHandle.TryGetLoggedInUser(identity, serverUri.AbsoluteUri, out var userHandle)) { return(new User(userHandle)); } return(null); }
/// <summary> /// Logs the user in to the Realm Object Server. /// </summary> /// <param name="credentials">The credentials to use for authentication.</param> /// <param name="serverUrl">The URI of the server that the user is authenticated against.</param> /// <returns>An awaitable Task, that, upon completion, contains the logged in user.</returns> public static async Task <User> LoginAsync(Credentials credentials, Uri serverUrl) { SharedRealmHandleExtensions.DoInitialFileSystemConfiguration(); if (credentials.IdentityProvider == Credentials.Providers.AccessToken) { var identity = (string)credentials.UserInfo[Credentials.Keys.Identity]; var isAdmin = (bool)credentials.UserInfo[Credentials.Keys.IsAdmin]; return(new User(SyncUserHandle.GetSyncUser(identity, credentials.Token, serverUrl?.AbsoluteUri, isAdmin))); } var result = await AuthenticationHelper.Login(credentials, serverUrl); return(new User(SyncUserHandle.GetSyncUser(result.Item1, result.Item2, serverUrl.AbsoluteUri, isAdmin: false))); }
internal override Realm CreateRealm(RealmSchema schema) { var configuration = new Realms.Native.Configuration { schema_version = SchemaVersion }; var syncConfiguration = new Native.SyncConfiguration { SyncUserHandle = User.Handle, Url = ServerUri.ToString() }; var srHandle = SharedRealmHandleExtensions.OpenWithSync(configuration, syncConfiguration, schema, EncryptionKey); return(new Realm(srHandle, this, schema)); }
internal override Realm CreateRealm(RealmSchema schema) { var configuration = new Realms.Native.Configuration { Path = DatabasePath, schema_version = SchemaVersion, enable_cache = EnableCache }; var srHandle = SharedRealmHandleExtensions.OpenWithSync(configuration, ToNative(), schema, EncryptionKey); if (IsDynamic && !schema.Any()) { srHandle.GetSchema(nativeSchema => schema = RealmSchema.CreateFromObjectStoreSchema(nativeSchema)); } return(new Realm(srHandle, this, schema)); }
internal override Realm CreateRealm(RealmSchema schema) { var configuration = new Realms.Native.Configuration { Path = DatabasePath, schema_version = SchemaVersion }; var syncConfiguration = new Native.SyncConfiguration { SyncUserHandle = User.Handle, Url = ServerUri.ToString(), client_validate_ssl = EnableSSLValidation, }; var srHandle = SharedRealmHandleExtensions.OpenWithSync(configuration, syncConfiguration, schema, EncryptionKey); return(new Realm(srHandle, this, schema)); }
public static async Task <IQueryable <T> > SubscribeToObjectsAsync <T>(this Realm realm, string query) { Argument.NotNull(realm, nameof(realm)); Argument.Ensure(realm.Config is SyncConfigurationBase, "Cannot get a Session for a Realm without a SyncConfiguration", nameof(realm)); var type = typeof(T); if (!realm.Metadata.TryGetValue(type.GetTypeInfo().GetMappedOrOriginalName(), out var metadata) || metadata.Schema.Type.AsType() != type) { throw new ArgumentException($"The class {type.Name} is not in the limited set of classes for this realm"); } var tcs = new TaskCompletionSource <ResultsHandle>(); SharedRealmHandleExtensions.SubscribeForObjects(realm.SharedRealmHandle, type, query, tcs); var resultsHandle = await tcs.Task; return(new RealmResults <T>(realm, metadata, resultsHandle)); }
/// <summary> /// Attempts to reconnect all sessions. /// </summary> /// <remarks> /// By default, the sync engine will attempt to reconnect sessions at incrementing intervals. This method is /// useful when you are monitoring connectivity yourself, using e.g. /// <see href="https://github.com/jamesmontemagno/ConnectivityPlugin">Connectivity Plugin</see> or through the /// native connectivity API and you wish to cancel that delay and try to reconnect immediately. /// </remarks> public static void Reconnect() { SharedRealmHandleExtensions.ReconnectSessions(); }
/// <summary> /// Initializes a new instance of the <see cref="SyncConfiguration"/> class. /// </summary> /// <param name="user">A valid <see cref="User"/>.</param> /// <param name="serverUri">A unique <see cref="Uri"/> that identifies the Realm. In URIs, <c>~</c> can be used as a placeholder for a user Id.</param> /// <param name="optionalPath">Path to the realm, must be a valid full path for the current platform, relative subdirectory, or just filename.</param> public SyncConfiguration(User user, Uri serverUri, string optionalPath = null) : base(optionalPath ?? SharedRealmHandleExtensions.GetRealmPath(user, serverUri)) { if (user == null) { throw new ArgumentNullException(nameof(user)); } if (serverUri == null) { throw new ArgumentNullException(nameof(serverUri)); } User = user; ServerUri = serverUri; }
/// <summary> /// Sets the feature token, associated with your edition. You only need to call it if you're using a professional /// or higher edition and only on platforms where features are disabled for lower editions. /// </summary> /// <param name="token">The feature token provided to you by the Realm team.</param> /// <seealso href="https://realm.io/docs/realm-object-server/pe-ee/#enabling-professional-and-enterprise-apis"> /// See more details on Enabling Professional and Enterprise APIs in the documentation. /// </seealso> public static void SetFeatureToken(string token) { Argument.NotNullOrEmpty(token, nameof(token)); SharedRealmHandleExtensions.SetFeatureToken(token); }