Syncing data to cloud

Amplify.addPlugin(AWSDataStorePlugin())
// Add this line.
Amplify.addPlugin(AWSApiPlugin())
Amplify.configure(applicationContext)

Amplify.DataStore.save(post, Post.TITLE.beginsWith("[Amplify]"),
    { Log.i("MyAmplifyApp", "Post updated successfully!") },
    { Log.e("MyAmplifyApp", "Could not update post, maybe the title has been changed?", it) }
)

try {
    Amplify.DataStore.save(post, Post.TITLE.beginsWith("[Amplify]"))
    Log.i("MyAmplifyApp", "Post updated successfully!") 
} catch (error: DataStoreException) {
    Log.e("MyAmplifyApp", "Could not update post, maybe the title has been changed?", error) 
}

RxAmplify.DataStore.save(post, Post.TITLE.beginsWith("[Amplify]"))
    .subscribe(
        update -> Log.i("MyAmplifyApp", "Post updated successfully!"),
        failure -> Log.e("MyAmplifyApp", "Could not update post, maybe the title has been changed?", failure)
    );

// Tests only against the local state
if (post.title.startsWith("[Amplify]")) {
    Amplify.DataStore.save(post,
        { /* handle result */ },
        { /* handle failure */}
    )
}

// Only applies the update if the data in the remote backend satisfies the criteria
Amplify.DataStore.save(post, Post.TITLE.beginsWith("[Amplify]"),
    { /* handle result */ },
    { /* handle failure */ }
)

// Tests only against the local state
if (post.title.starts("[Amplify]")) {
    try {
        Amplify.DataStore.save(post)
    } catch (error: DataStoreException) {
        // handle error
    }
}

// Only applies the update if the data in the remote backend satisfies the criteria
Amplify.DataStore.save(post, Post.TITLE.beginsWith("[Amplify]"),
    { /* handle result */ },
    { /* handle failure */ }
)

// Tests only against the local state
if (post.getTitle().startsWith("[Amplify]")) {
    RxAmplify.DataStore.save(post)
        .subscribe(
            update -> { /* handle result */ },
            failure -> { /* handle failure */}
        );
}

// Only applies the update if the data in the remote backend satisfies the criteria
RxAmplify.DataStore.save(post, Post.TITLE.beginsWith("[Amplify]"))
    .subscribe(
        update -> { /* handle result */ },
        failure -> { /* handle failure */ }
    );

Amplify.Hub.subscribe(HubChannel.AUTH,
    {
        // Listen for sign out events.
        it.name.equals(AuthChannelEventName.SIGNED_OUT.toString())
    },
    {
        // When one arrives, clear the DataStore.
        Amplify.DataStore.clear(
            { Log.i("MyAmplifyApp", "DataStore is cleared") },
            { Log.e("MyAmplifyApp", "Failed to clear DataStore") }
        )
    }
)

Amplify.Hub.subscribe(HubChannel.AUTH)
    { it.name == AuthChannelEventName.SIGNED_OUT.toString() }
    // When sign out event arrives, clear the DataStore.
    .onEach { Amplify.DataStore.clear() }
    .catch { Log.e("MyAmplifyApp", "Failed to clear DataStore.", it) }
    .collect { Log.i("MyAmplifyApp", "DataStore is cleared.") }

// Listen for sign out events.
final String signedOutEventName = AuthChannelEventName.SIGNED_OUT.toString();

RxAmplify.Hub.on(HubChannel.AUTH)
    .filter(event -> signedOutEventName.equals(event.getName()))
    .flatMapObservable(RxAmplify.DataStore::clear)
    .subscribe(
        () -> Log.i("MyAmplifyApp", "DataStore is cleared."),
        failure -> Log.e("MyAmplifyApp", "Failed to clear DataStore.")
    );

Amplify.addPlugin(AWSDataStorePlugin.builder().dataStoreConfiguration(
    DataStoreConfiguration.builder()
        .syncExpression(Post::class.java) { Post.RATING.gt(5) }
        .syncExpression(Comment::class.java) { Comment.STATUS.eq("active") }
        .build())
    .build())

RxAmplify.addPlugin(AWSDataStorePlugin.builder().dataStoreConfiguration(
    DataStoreConfiguration.builder()
        .syncExpression(Post.class, () -> Post.RATING.gt(5))
        .syncExpression(Comment.class, () -> Comment.STATUS.eq("active"))
        .build())
    .build());

var rating: Int = 5;

fun initialize() {
    Amplify.addPlugin(AWSDataStorePlugin.builder().dataStoreConfiguration(
        DataStoreConfiguration.builder()
            .syncExpression(Post::class.java) { Post.RATING.gt(rating) }
            .build())
        .build())
}

fun changeSync() {
    rating = 1;
    Amplify.DataStore.stop(
        {
            Amplify.DataStore.start(
                { Log.i("MyAmplifyApp", "DataStore started") },
                { Log.e("MyAmplifyApp", "Error starting DataStore", it) }
            )
        },
        { Log.e("MyAmplifyApp", "Error stopping DataStore", it) }
    )
}

var rating = 5

fun initialize() {
    Amplify.addPlugin(AWSDataStorePlugin.builder().dataStoreConfiguration(
        DataStoreConfiguration.builder()
            .syncExpression(Post::class.java) { Post.RATING.gt(rating) }
            .build())
        .build())
}

suspend fun changeSync() {
    rating = 1
    try {
        Amplify.DataStore.stop()
        Amplify.DataStore.start()
        Log.i("MyAmplifyApp", "DataStore started")
    } catch (error: DataStoreException) {
        Log.w("MyAmplifyApp", "Failed to restart DataStore", error)
    }
}

public Integer rating = 5;

public void initialize() {
    RxAmplify.addPlugin(AWSDataStorePlugin.builder().dataStoreConfiguration(
        DataStoreConfiguration.builder()
            .syncExpression(Post.class, () -> Post.RATING.gt(rating))
            .build())
        .build());
}

public void changeSync() {
    rating = 1;
    RxAmplify.DataStore.stop()
        .andThen(RxAmplify.DataStore.start())
        .subscribe(
            () -> Log.i("MyAmplifyApp", "DataStore restarted"),
            error -> Log.e("MyAmplifyApp", "Error restarting DataStore: ", error)
        );
}

fun changeSync() {
    rating = 8;
    Amplify.DataStore.clear(
        {
            Amplify.DataStore.start(
                { Log.i("MyAmplifyApp", "DataStore started") },
                { Log.e("MyAmplifyApp", "Error starting DataStore", it) }
            )
        },
        { Log.e("MyAmplifyApp", "Error clearing DataStore", it) }
    )
}

suspend fun changeSync() {
    rating = 8
    try {
        Amplify.DataStore.clear()
        Amplify.DataStore.start()
        Log.i("MyAmplifyApp", "DataStore started")
    } catch (error: DataStoreException) {
        Log.w("MyAmplifyApp", "Error clearing/starting DataStore", error)
    }
}

public void changeSync() {
    rating = 8;
    RxAmplify.DataStore.clear()
        .andThen(RxAmplify.DataStore.start()
        .subscribe(
            () -> Log.i("MyAmplifyApp", "DataStore cleared and restarted"),
            error -> Log.e("MyAmplifyApp", "Error clearing or restarting DataStore: ", error)
        );
}

var rating = null

fun initialize() {
    Amplify.addPlugin(AWSDataStorePlugin.builder().dataStoreConfiguration(
        DataStoreConfiguration.builder()
            .syncExpression(Post::class.java) {
                if (rating != null) {
                    Post.RATING.gt(rating)
                }
                QueryPredicates.all()
            }
            .build())
        .build())
}

public Integer rating = null;

public void initialize() {
    RxAmplify.addPlugin(AWSDataStorePlugin.builder().dataStoreConfiguration(
        DataStoreConfiguration.builder()
            .syncExpression(Post.class, () -> {
                if (rating != null) {
                    return () -> Post.RATING.gt(rating);
                }
                return QueryPredicates.all();
            })
            .build())
        .build());
}

Amplify.addPlugin(AWSDataStorePlugin.builder().dataStoreConfiguration(
    DataStoreConfiguration.builder()
        .syncExpression(User::class.java) { User.LAST_NAME.eq("Doe") }
        .build())
    .build())

// OR

Amplify.addPlugin(AWSDataStorePlugin.builder().dataStoreConfiguration(
    DataStoreConfiguration.builder()
        .syncExpression(User::class.java) { User.LAST_NAME.eq("Doe").and(User.CREATED_AT.gt("2020-10-10")) }
        .build())
    .build())

RxAmplify.addPlugin(AWSDataStorePlugin.builder().dataStoreConfiguration(
    DataStoreConfiguration.builder()
        .syncExpression(User.class, () -> User.LAST_NAME.eq("Doe"))
        .build())
    .build());

// OR

RxAmplify.addPlugin(AWSDataStorePlugin.builder().dataStoreConfiguration(
    DataStoreConfiguration.builder()
        .syncExpression(User.class, () -> User.LAST_NAME.eq("Doe").and(User.CREATED_AT.gt("2020-10-10")))
        .build())
    .build());