+ Learn Appwrite Auth, Databases, and more with Android/Java.
+
+
diff --git a/src/routes/docs/tutorials/android/step-1/+page.markdoc b/src/routes/docs/tutorials/android/step-1/+page.markdoc
index f3e111bd41..ae720ba11e 100644
--- a/src/routes/docs/tutorials/android/step-1/+page.markdoc
+++ b/src/routes/docs/tutorials/android/step-1/+page.markdoc
@@ -1,15 +1,25 @@
---
layout: tutorial
-title: Coming soon
+title: Recipewrite - a Recipe sharing app
description: Learn to build an Android app with no backend code using an Appwrite backend.
step: 1
+difficulty: beginner
---
-Improve the docs, add this guide.
+**Recipewrite**: an android app to share and find all the delicious recipes that left you licking your fingers.
+In this tutorial, you will build Recipewrite with Appwrite, Android and Java.
-We still don't have this guide in place, but we do have some great news.
-The Appwrite docs, just like Appwrite, is completely open sourced.
-This means, anyone can help improve them and add new guides and tutorials.
+# Concepts {% #concepts %}
+This tutorial will introduce the following concepts:
-If you see this page, **we're actively looking for contributions to this page**.
-Follow our contribution guidelines, open a PR to [our Website repo](https://github.com/appwrite/website), and collaborate with our core team to improve this page.
\ No newline at end of file
+1. Setting up your first project
+2. Authentication
+3. Databases and collections
+4. Database Queries
+5. Pagination
+
+# Prerequisites {% #prerequisites %}
+1. Basic knowledge of Java.
+2. Have [Java](https://www.java.com/en/) and [Android Studio](https://developer.android.com/studio) installed on your computer
+
+If you are stuck at any point, you can refer to the final code repository of this tutorial [here](https://github.com/letsintegreat/Recipewrite).
\ No newline at end of file
diff --git a/src/routes/docs/tutorials/android/step-2/+page.markdoc b/src/routes/docs/tutorials/android/step-2/+page.markdoc
new file mode 100644
index 0000000000..f22abb23b2
--- /dev/null
+++ b/src/routes/docs/tutorials/android/step-2/+page.markdoc
@@ -0,0 +1,28 @@
+---
+layout: tutorial
+title: Initialize project
+description: Learn to build an Android app with no backend code using an Appwrite backend.
+step: 2
+difficulty: beginner
+---
+
+# Initialize Android Studio project {% #initialize-android-studio-project %}
+
+1. Fire up your Android Studio
+
+2. Go to **File / New / New Project**
+
+3. Select **Empty Activity**
+
+4. Name your project **Recipewrite**, select Java language, and minimum SDK would be **23**
+
+# Add dependencies {% #add-dependencies %}
+
+1. Open **app/build.gradle** file
+
+2. Find `dependencies` block, and add the following dependencies along with existing ones
+ ```
+ implementation 'io.appwrite:sdk-for-android:4.0.0'
+ ```
+
+3. Update `compileSdk` and `targetSdk` to **34** in the same file
\ No newline at end of file
diff --git a/src/routes/docs/tutorials/android/step-3/+page.markdoc b/src/routes/docs/tutorials/android/step-3/+page.markdoc
new file mode 100644
index 0000000000..2c3ba04629
--- /dev/null
+++ b/src/routes/docs/tutorials/android/step-3/+page.markdoc
@@ -0,0 +1,70 @@
+---
+layout: tutorial
+title: Setup Appwrite
+description: Learn to build an Android app with no backend code using an Appwrite backend.
+step: 3
+difficulty: beginner
+---
+
+# Create project {% #create-project %}
+
+Head to the [Appwrite Console](https://cloud.appwrite.io/console).
+
+{% only_dark %}
+
+{% /only_dark %}
+{% only_light %}
+
+{% /only_light %}
+
+If this is your first time using Appwrite, create an account and create your first project.
+
+Give your project a new name, and set **Project ID** to `recipewrite`.
+
+Then, under **Add a platform**, add a **Android app**. **Package Name** can be found in app level gradle file.
+
+{% only_dark %}
+
+{% /only_dark %}
+{% only_light %}
+
+{% /only_light %}
+
+You can skip the optional steps.
+
+# Connect your app with appwrite {% #connect-your-app-with-appwrite %}
+
+Create **Appwrite.java**, this will handle our app's interaction with Appwrite server.
+
+```java
+public class Appwrite {
+ private static Client client;
+ private static Account account;
+ private static Databases databases;
+
+ private static final String projectID = "recipewrite";
+ private static final String endpoint = "https://cloud.appwrite.io/v1"; // Add local address if you are running appwrite locally
+
+ public static void init(Context context) {
+ client = new Client(context);
+ client.setEndpoint(endpoint);
+ client.setProject(projectID);
+ client.setSelfSigned(true);
+
+ account = new Account(client);
+ databases = new Databases(client);
+ }
+}
+```
+
+Finally, call this `init` method in `onCreate` method of **MainActivity.java**.
+
+```java
+@Override
+protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+
+ Appwrite.init(this);
+}
+```
\ No newline at end of file
diff --git a/src/routes/docs/tutorials/android/step-4/+page.markdoc b/src/routes/docs/tutorials/android/step-4/+page.markdoc
new file mode 100644
index 0000000000..1c02ec4da6
--- /dev/null
+++ b/src/routes/docs/tutorials/android/step-4/+page.markdoc
@@ -0,0 +1,507 @@
+---
+layout: tutorial
+title: Authentication
+description: Learn to build an Android app with no backend code using an Appwrite backend.
+step: 4
+difficulty: beginner
+---
+
+# User Flow {% #user-flow %}
+
+This is the user flow that we are going to achieve in this page
+
+
+
+Keeping the userflow in mind, let us start by initializing three new empty activities -
+
+- **LoginActivity**
+- **RegisterActivity**
+- **HomeActivity**
+
+# Appwrite methods {% #appwrite-methods %}
+
+Let us implement some utility methods in **Appwrite.java**
+
+- **onGetAccount**
+
+It will be used in **MainActivity** to check if the user is already logged in or not.
+
+```java
+public static void onGetAccount(Context context) {
+ try {
+ /* Account.get is used to get the currently logged in user. */
+ account.get(new CoroutineCallback<>((result, error) -> {
+
+ Intent intent;
+
+ if (error != null) { /* User isn't logged in. */
+ intent = new Intent(context, LoginActivity.class);
+ } else { /* User is logged in. */
+ intent = new Intent(context, HomeActivity.class);
+
+ /* This will pass the account name to HomeActivity */
+ intent.putExtra("name", result.getName());
+ }
+
+ intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+ context.startActivity(intent);
+ ((Activity) context).finish();
+ }));
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+}
+```
+
+- **onLogin**
+
+This method will take in email and password, and will try to log the user in.
+
+```java
+public static void onLogin(Context context, String email, String password) {
+ /* Allow the user to login into their account by providing a valid email and password combination. */
+ account.createEmailSession(
+ email,
+ password,
+ new CoroutineCallback<>((result, error) -> {
+ if (error != null) {
+ /* Login unsuccessful */
+ error.printStackTrace();
+ return;
+ }
+
+ /* Get current user and redirect to HomeActivity */
+ onGetAccount(context);
+ })
+ );
+}
+```
+
+- **onCreateAccount**
+
+This method will take in email, password and name, and will try to register our new user to the app.
+
+```java
+public static void onCreateAccount(Context context, String email, String password, String name) {
+ try {
+ /* Allow a new user to register a new account */
+ account.create(
+ ID.Companion.unique(),
+ email,
+ password,
+ name,
+ new CoroutineCallback<>((result, error) -> {
+ if (error != null) {
+ /* Create account unsuccessful */
+ error.printStackTrace();
+ return;
+ }
+
+ /* Log the new user in, and redirect to HomeActivity */
+ onLogin(context, email, password);
+ })
+ );
+ } catch (AppwriteException e) {
+ e.printStackTrace();
+ }
+}
+```
+
+- **onLogout**
+
+```java
+public static void onLogout(Context context) {
+ /* Logout the user. Use 'current' as the session ID to logout on this device, use a session ID to logout on another device. */
+ account.deleteSession(
+ "current",
+ new CoroutineCallback<>((result, error) -> {
+ if (error != null) {
+ /* Logout unsuccessful */
+ error.printStackTrace();
+ return;
+ }
+
+ /* Redirect to LoginActivity if logout successful */
+ Intent intent = new Intent(context, LoginActivity.class);
+ intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+ context.startActivity(intent);
+ ((Activity) context).finish();
+ })
+ );
+}
+```
+
+# Main Activity {% #main-activity %}
+
+As shown in the userflow, main activity will just check if the user is already logged in or not. It will redirect accordingly.
+
+## **activity_main.xml**
+
+We just need a progress bar here.
+
+```xml
+
+```
+
+## **MainActivity.java**
+
+We will reuse our **onGetAccount** method here.
+
+```java
+@Override
+protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO);
+ setContentView(R.layout.activity_main);
+
+ /* Ensure this is the first time onCreate is called. */
+ /* This will prevent appwrite to be initialized multiple times */
+ if (savedInstanceState == null) {
+ Appwrite.init(this);
+ Appwrite.onGetAccount(this);
+ }
+}
+```
+
+# Login Activity {% #login-activity %}
+
+## **activity_login.xml**
+
+We will need four elements here.
+
+- Email field
+
+```xml
+
+```
+
+- Password field
+
+```xml
+
+```
+
+- Login button to submit the entered email and password
+
+```xml
+
+```
+
+- Register button to launch **RegisterActivity**
+
+```xml
+
+```
+
+## **LoginActivity.java**
+
+Now let us write logic of button clicks. There are a couple of ways to implement `OnClickListener` on views. Here we are going to use `View.OnClickListener` interface.
+
+Change the definition of `LoginActivity` to implement `View.OnClickListener` interface.
+
+```java
+public class LoginActivity extends AppCompatActivity implements View.OnClickListener
+```
+
+Declare UI views within this class
+
+```java
+EditText emailEditText, passwordEditText;
+Button loginButton, registerButton;
+```
+
+Initialize these variables in `onCreate` method.
+
+```java
+emailEditText = findViewById(R.id.email_edit_text);
+passwordEditText = findViewById(R.id.password_edit_text);
+loginButton = findViewById(R.id.login_button);
+registerButton = findViewById(R.id.register_button);
+```
+
+Set `OnClickListener`s on both the buttons inside `onCreate` method.
+
+```java
+loginButton.setOnClickListener(this);
+registerButton.setOnClickListener(this);
+```
+
+Now override the `onClick` method of `LoginActivity` to finally write the click logic.
+
+```java
+@Override
+public void onClick(View view) {
+
+ /* Extract user input */
+ String email = emailEditText.getText().toString();
+ String password = passwordEditText.getText().toString();
+
+ switch ((view.getId())) {
+ case R.id.login_button:
+ /* Do something */
+ break;
+
+ case R.id.register_button:
+ /* Do something */
+ break;
+ }
+}
+```
+
+We can simply use our Appwrite method to login the user, if **login_button** is pressed -
+
+```java
+case R.id.login_button:
+ Appwrite.onLogin(this, email, password);
+ break;
+```
+
+And redirect to **RegisterActivity**, if **register_button** is pressed -
+
+```java
+case R.id.register_button:
+ /* Redirect to RegisterActivity */
+ Intent intent = new Intent(this, RegisterActivity.class);
+ intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_TASK_ON_HOME);
+ startActivity(intent);
+ this.finish();
+ break;
+```
+
+# Register Activity {% #register-activity %}
+
+## **activity_register.xml**
+
+We will need five elements here.
+
+- Name field
+
+```xml
+
+```
+
+- Email field
+
+```xml
+
+```
+
+- Password field
+
+```xml
+
+```
+
+- Register button to submit the entered name, email and password
+
+```xml
+
+```
+
+- Login button to launch **LoginActivity**
+
+```xml
+
+```
+
+## **RegisterActivity.java**
+
+Change the definition of `RegisterActivity` to implement `View.OnClickListener` interface.
+
+```java
+public class RegisterActivity extends AppCompatActivity implements View.OnClickListener
+```
+
+Declare UI views within this class
+
+```java
+EditText nameEditText, emailEditText, passwordEditText;
+Button loginButton, registerButton;
+```
+
+Initialize these variables in `onCreate` method.
+
+```java
+nameEditText = findViewById(R.id.name_edit_text);
+emailEditText = findViewById(R.id.email_edit_text);
+passwordEditText = findViewById(R.id.password_edit_text);
+loginButton = findViewById(R.id.login_button);
+registerButton = findViewById(R.id.register_button);
+```
+
+Set `OnClickListener`s on both the buttons inside `onCreate` method.
+
+```java
+registerButton.setOnClickListener(this);
+loginButton.setOnClickListener(this);
+```
+
+Now override the `onClick` method of `RegisterActivity` to finally write the click logic.
+
+```java
+@Override
+public void onClick(View view) {
+
+ /* Extract user input */
+ String name = nameEditText.getText().toString();
+ String email = emailEditText.getText().toString();
+ String password = passwordEditText.getText().toString();
+
+ switch ((view.getId())) {
+ case R.id.register_button:
+ /* Do something */
+ break;
+
+ case R.id.login_button:
+ /* Do something */
+ break;
+ }
+}
+```
+
+We can simply use our Appwrite method to register the user, if **register_button** is pressed -
+
+```java
+case R.id.register_button:
+ Appwrite.onCreateAccount(this, email, password, name);
+ break;
+```
+
+And redirect to **LoginActivity**, if **login_button** is pressed -
+
+```java
+case R.id.login_button:
+ /* Redirect to LoginActivity */
+ Intent intent = new Intent(this, LoginActivity.class);
+ intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_TASK_ON_HOME);
+ startActivity(intent);
+ this.finish();
+ break;
+```
+
+# Home Activity {% #home-activity %}
+
+Finally, we want to add a logout button in the app bar of **HomeActivity**.
+
+Let us start by creating a vector asset for logout icon.
+
+Right click on **res** folder, click **New**, click **Vector Asset**.
+
+Choose logout icon in **Clip Art** and then give the asset **logout** name.
+
+Now, create a new file **res/menu/mymenu.xml**
+
+```xml
+
+```
+
+Now, override ```onCreateOptionsMenu``` method of ```HomeActivity``` in order to show the above defined icon on the app bar.
+
+```java
+@Override
+public boolean onCreateOptionsMenu(Menu menu) {
+ getMenuInflater().inflate(R.menu.mymenu, menu);
+ return super.onCreateOptionsMenu(menu);
+}
+```
+
+Finally, to write its click logic, override ```onOptionsItemSelected``` method and use our already defined appwrite method ```onLogout```.
+
+```java
+@Override
+public boolean onOptionsItemSelected(MenuItem item) {
+ int id = item.getItemId();
+
+ if (id == R.id.action_logout) {
+ Appwrite.onLogout(this);
+ }
+
+ return super.onOptionsItemSelected(item);
+}
+```
+
+Kudos! We started from zero and now we have a full fledged authentication system.
\ No newline at end of file
diff --git a/src/routes/docs/tutorials/android/step-5/+page.markdoc b/src/routes/docs/tutorials/android/step-5/+page.markdoc
new file mode 100644
index 0000000000..8f020499a4
--- /dev/null
+++ b/src/routes/docs/tutorials/android/step-5/+page.markdoc
@@ -0,0 +1,307 @@
+---
+layout: tutorial
+title: Database
+description: Learn to build an Android app with no backend code using an Appwrite backend.
+step: 5
+difficulty: beginner
+---
+
+# Create database and collection {% #create-database-and-collection %}
+
+Head to the [Appwrite Console](https://cloud.appwrite.io/console).
+
+In **Databases** tab, click on **Create database**, give it any name and set Database ID to `default`.
+
+Click on **Create collection**, give it any name and set Collection ID to `recipes`.
+
+In **Attributes** tab, create two new attributes.
+
+- **name**
+ - **Type**: String
+ - **Key**: name
+ - **Size**: 100
+ - **Required**: true
+
+- **recipe**
+ - **Type**: String
+ - **Key**: recipe
+ - **Size**: 1024
+ - **Required**: true
+
+In **Indexes** tab, create a new index. This will be important for search feature of our app.
+
+- **recipe_index**
+ - **Type**: FullText
+ - **Attribute**: recipe
+
+In **Settings** tab, find **Permissions** heading, add **Any** role and turn on all options, i.e., Create, Read, Update and Delete. You can learn more about Appwrite permissions [here](https://appwrite.io/docs/advanced/platform/permissions).
+
+# Recipe Model {% #recipe-model %}
+
+Create a new java class: **RecipeModel**. Recipe model will have two string members - **name** and **recipe**.
+
+```java
+public class RecipeModel {
+ public String name;
+ public String recipe;
+
+ public Map toJson() {
+ Map ret = new HashMap<>();
+ ret.put("name", name);
+ ret.put("recipe", recipe);
+ return ret;
+ }
+
+ public RecipeModel(Map data) {
+ this.name = data.get("name");
+ this.recipe = data.get("recipe");
+ }
+
+ public RecipeModel(String name, String recipe) {
+ this.name = name;
+ this.recipe = recipe;
+ }
+
+ @Override
+ public String toString() {
+ return name + " shared:\n" + recipe;
+ }
+}
+```
+
+# Appwrite methods {% #appwrite-methods %}
+
+Now we are going to write database methods in **Appwrite.java**, just like we did in authentication part.
+
+But first let's add `databaseID` and `collectionID` member variables to our `Appwrite` class.
+
+```java
+private static final String databaseID = "default";
+private static final String collectionID = "recipes";
+```
+
+## **onAddRecipe**
+
+This method will be invoked to add a new recipe to the database.
+
+```java
+public static void onAddRecipe(RecipeModel recipeModel, CoroutineCallback coroutineCallback) {
+ try {
+ /* Create a new Document. */
+ databases.createDocument(
+ databaseID,
+ collectionID,
+ ID.Companion.unique(),
+ recipeModel.toJson(),
+ coroutineCallback
+ );
+ } catch (AppwriteException e) {
+ e.printStackTrace();
+ }
+}
+```
+
+## **onListRecipes**
+
+This method will fetch the list of recipes stored in our recipes collection.
+
+```java
+public static void listRecipes(CoroutineCallback coroutineCallback) {
+ try {
+ /* Get a list of all the user's documents in a given collection. */
+ databases.listDocuments(
+ databaseID,
+ collectionID,
+ coroutineCallback
+ );
+ } catch (AppwriteException e) {
+ e.printStackTrace();
+ }
+}
+```
+
+# Add a recipe {% #add-a-recipe %}
+
+Let us implement the feature to add a finger-licking recipe to our database. We need two pieces of information to create a new recipe model, name of current user and the recipe they want to share.
+
+Remember we passed name of the user to **HomeActivity** in `onGetAccount` method of `Appwrite` class? Let us extract that out.
+
+Declare a string member variable `name` inside **HomeActivity**.
+
+```java
+String name;
+```
+
+Extract name from intent in `onCreate` method.
+
+```java
+name = getIntent().getStringExtra("name");
+```
+
+Now, in order to get user's delicious recipe, let us make a floating action button. Again, use **Vector Asset** to make a new icon. Choose **add** icon in clip art, and then name it **add.xml**.
+
+Add a `FloatingActionButton` to **activity_home.xml**
+
+```xml
+
+```
+
+Update definition of **HomeActivity** to implement `View.OnClickListener`
+
+```java
+public class HomeActivity extends AppCompatActivity implements View.OnClickListener
+```
+
+Declare a `FloatingActionButton` member variable of **HomeActivity**
+
+```java
+FloatingActionButton fab;
+```
+
+Initialize it in `onCreate` method.
+
+```java
+fab = findViewById(R.id.floatingActionButton);
+fab.setOnClickListener(this);
+```
+
+Now, override `onClick` to write its click logic. We are going to show an `AlertDialog` with a text field to capture user's recipe and then use our appwrite method to add the new recipe to database.
+
+```java
+@Override
+public void onClick(View view) {
+ switch ((view.getId())) {
+
+ case R.id.floatingActionButton:
+
+ /* Declare the builder */
+ AlertDialog.Builder builder = new AlertDialog.Builder(this);
+
+ /* Set its title */
+ builder.setTitle("Add Recipe");
+
+ /* Create a new text field for recipe */
+ final EditText input = new EditText(this);
+ builder.setView(input);
+
+ /* Add an 'Add' button to the dialog */
+ builder.setPositiveButton("Add", (dialog, which) -> {
+
+ /* Extract user input */
+ String recipe = input.getText().toString();
+
+ /* Create a new recipe model */
+ RecipeModel recipeModel = new RecipeModel(name, recipe);
+
+ /* Add the new recipe to database */
+ Appwrite.onAddRecipe(recipeModel, new CoroutineCallback<>((result, error) -> {
+ /* Do something on success addition to database */
+ }));
+ });
+
+ /* Add a 'Cancel' button to cancel the dialog */
+ builder.setNegativeButton("Cancel", (dialog, which) -> dialog.cancel());
+
+ /* Finally show the dialog */
+ builder.show();
+ break;
+ }
+}
+```
+
+# List recipes {% #list-recipes %}
+
+Now, let us show all the delicious recipes that we've got stacked in our database.
+
+Add a `ListView` in **activity_home.xml**
+
+```xml
+
+
+
+```
+
+Now, in **HomeActivity** class, add the following member variables
+
+```java
+ListView listView;
+ArrayList recipes = new ArrayList<>();
+ArrayAdapter arr;
+```
+
+Initialize `listView` and `arr` in `onCreate` method and set `arr` as adapter to `listView`.
+
+```java
+listView = findViewById(R.id.list_view);
+arr = new ArrayAdapter<>(
+ this,
+ R.layout.list_item,
+ recipes
+);
+listView.setAdapter(arr);
+```
+
+Create a new file **res/layout/list_item.xml**
+
+```xml
+
+
+
+```
+
+Now finally, let's write a method `reloadList` which will fetch the list of recipes from database, and update the UI.
+
+```java
+private void reloadList() {
+ Appwrite.listRecipes(new CoroutineCallback<>((result, error) -> {
+ if (error != null) {
+ error.printStackTrace();
+ return;
+ }
+
+ /* Clear recipes list first as we have fresh data */
+ recipes.clear();
+ if (result != null) {
+ for (Object document: result.getDocuments()) {
+ /* Extract JSON data from the response */
+ Map data = (Map) ((Document) document).getData();
+
+ /* Create recipe model from that JSON data */
+ RecipeModel recipe = new RecipeModel(data);
+
+ /* Add that model to our list of recipes */
+ recipes.add(recipe);
+ }
+ }
+
+ /* notify the adapter about the changes in list of recipes */
+ runOnUiThread(() -> arr.notifyDataSetChanged());
+ }));
+}
+```
+
+Call `reloadList`
+
+1. at the end of `onCreate` in order to load the list on startup.
+2. in `onClick`, under the comment `Do something on success addition to database` in order to reload the list once we have added a new recipe.
+
+Phew! We have successfully connected the app to the database, you can see both **add** and **list** in action by this time!
\ No newline at end of file
diff --git a/src/routes/docs/tutorials/android/step-6/+page.markdoc b/src/routes/docs/tutorials/android/step-6/+page.markdoc
new file mode 100644
index 0000000000..f009aa4e43
--- /dev/null
+++ b/src/routes/docs/tutorials/android/step-6/+page.markdoc
@@ -0,0 +1,116 @@
+---
+layout: tutorial
+title: Database Queries
+description: Learn to build an Android app with no backend code using an Appwrite backend.
+step: 6
+difficulty: beginner
+---
+
+# Introduction {% #introduction %}
+
+Many list endpoints in Appwrite allow you to filter, sort, and paginate results using queries. Appwrite provides a common set of syntax to build queries. Learn more about Appwrite Queries [here](https://appwrite.io/docs/products/databases/queries).
+
+To demonstrate how queries are used in java, we are going to implement **search feature** in our **Recipewrite** app.
+
+# Search feature {% #search-feature %}
+
+Let us show a search icon next to logout icon in app bar of our Home Activity. Again, use **Asset Studio** to add a **search** icon from clip art, then name it **search.xml**.
+
+Add the following icon in **res/layout/mymenu.xml**
+
+```xml
+
+```
+
+Introduce a ```search``` argument in our ```listRecipes``` method of ```Appwrite.java``` file. This argument will be an empty string if user doesn't want to perform a search, otherwise it will contain the search query.
+
+```java
+public static void listRecipes(String search, CoroutineCallback coroutineCallback) {
+
+ ArrayList queries = new ArrayList<>();
+ if (!search.isEmpty()) {
+ /* Perform the search on 'recipe' attribute */
+ queries.add(Query.Companion.search("recipe", search));
+ }
+
+ try {
+ /* Get a list of all the user's documents in a given collection. */
+ databases.listDocuments(
+ databaseID,
+ collectionID,
+ queries,
+ coroutineCallback
+ );
+ } catch (AppwriteException e) {
+ e.printStackTrace();
+ }
+}
+```
+
+Now, create a new String member variable `search` in **HomeActivity**.
+
+```java
+String search = "";
+```
+
+Pass this argument to **listRecipes** inside **reloadList** method
+
+```java
+Appwrite.listRecipes(search, new CoroutineCallback<>((result, error) -> {
+```
+
+Finally, update the `onOptionsItemSelected` method to write search button's click logic.
+
+```java
+@Override
+public boolean onOptionsItemSelected(MenuItem item) {
+ int id = item.getItemId();
+
+ if (id == R.id.action_logout) {
+ Appwrite.onLogout(this);
+ } else if (id == R.id.action_search) {
+
+ /* Declare an AlertDialog to capture search query from user */
+ AlertDialog.Builder builder = new AlertDialog.Builder(this);
+ builder.setTitle("Search Recipe");
+
+ /* Initialize a new text field to take user input */
+ final EditText input = new EditText(this);
+
+ /* Set its initial value to be the current search query */
+ input.setText(search);
+ builder.setView(input);
+
+ /* Add a 'Search' button to perform the search */
+ builder.setPositiveButton("Search", (dialog, which) -> {
+
+ /* Extract user input */
+ search = input.getText().toString();
+ /* reload the list */
+ reloadList();
+ });
+
+ /* Add a 'Clear' button to remove current search query */
+ builder.setNegativeButton("Clear", (dialog, which) -> {
+ /* reset search to empty string */
+ search = "";
+ /* reload the list */
+ reloadList();
+ /* close the dialog */
+ dialog.cancel();
+ });
+
+ /* Finally show the dialog */
+ builder.show();
+ }
+
+ return super.onOptionsItemSelected(item);
+}
+```
+
+There you have the search feature in action!
\ No newline at end of file
diff --git a/src/routes/docs/tutorials/android/step-7/+page.markdoc b/src/routes/docs/tutorials/android/step-7/+page.markdoc
new file mode 100644
index 0000000000..892ae00ff3
--- /dev/null
+++ b/src/routes/docs/tutorials/android/step-7/+page.markdoc
@@ -0,0 +1,158 @@
+---
+layout: tutorial
+title: Pagination
+description: Learn to build an Android app with no backend code using an Appwrite backend.
+step: 7
+difficulty: beginner
+---
+
+# Introduction {% #introduction %}
+
+As your database grows in size, you'll need to paginate results returned. Pagination improves performance by returning a subset of results that match a query at a time, called a page.
+
+By default, list operations return 25 items per page, which can be changed using the ```Query.limit(25)``` operator. **Beware that large pages can degrade performance**.
+
+After reading a page of documents, pass the last document's ID into the ```Query.cursorAfter(lastId)``` query method to get the next page of documents. Pass the first document's ID into the ```Query.cursorBefore(firstId)``` query method to retrieve the previous page.
+
+Learn more about pagination [here](https://appwrite.io/docs/products/databases/pagination).
+
+# Pagination feature {% #pagination-feature %}
+
+Update the ```listRecipes``` method to take in ```lastDocumentId``` as an argument, and add appropriate query
+
+```java
+public static void listRecipes(String search, String lastDocumentId, CoroutineCallback coroutineCallback) {
+ ArrayList queries = new ArrayList<>();
+
+ if (!search.isEmpty()) {
+ /* Perform the search on 'recipe' attribute */
+ queries.add(Query.Companion.search("recipe", search));
+ }
+
+ if(!lastDocumentId.isEmpty()) {
+ /* This retrieves the next page */
+ queries.add(Query.Companion.cursorAfter(lastDocumentId));
+ }
+
+ try {
+ /* Get a list of all the user's documents in a given collection. */
+ databases.listDocuments(
+ databaseID,
+ collectionID,
+ queries,
+ coroutineCallback
+ );
+ } catch (AppwriteException e) {
+ e.printStackTrace();
+ }
+}
+```
+
+Declare the following member variables in ```HomeActivity``` class
+
+1. **recipesDocuments**: As we will be needing the documentId of the last document we have, let us maintain a list of documents.
+2. **loading**: This will ensure no two ```listRecipes``` operations happen at the same time.
+
+```java
+ArrayList recipesDocuments = new ArrayList<>();
+Boolean loading = false;
+```
+
+In ```reloadList``` method, set ```loading``` to true and false accordingly, pass an empty string to ```listRecipe``` as ```lastDocumentId``` and update `recipesDocuments` list along with `recipes` list.
+
+```java
+private void reloadList() {
+ loading = true;
+ Appwrite.listRecipes(search, "", new CoroutineCallback<>((result, error) -> {
+ if (error != null) {
+ error.printStackTrace();
+ return;
+ }
+
+ /* Clear recipes list first as we have fresh data */
+ recipes.clear();
+ recipesDocuments.clear();
+ if (result != null) {
+ for (Object document: result.getDocuments()) {
+ /* Extract JSON data from the response */
+ Map data = (Map) ((Document) document).getData();
+
+ /* Create recipe model from that JSON data */
+ RecipeModel recipe = new RecipeModel(data);
+
+ /* Add that model to our list of recipes */
+ recipes.add(recipe);
+ recipesDocuments.add((Document) document);
+ }
+ }
+
+ /* notify the adapter about the changes in list of recipes */
+ runOnUiThread(() -> arr.notifyDataSetChanged());
+ loading = false;
+ }));
+}
+```
+
+Write a new method ```loadNextPage``` which will pass the documentId of the last document we have in our UI, and append the result to the UI. It will be called every time user scrolls to the bottom of the `ListView`.
+
+```java
+private void loadNextPage() {
+ loading = true;
+ String lastDocumentId = "";
+
+ /* find the documentId of the last document we have on UI */
+ if (!recipesDocuments.isEmpty()) {
+ lastDocumentId = recipesDocuments.get(recipesDocuments.size() - 1).getId();
+ }
+
+ Appwrite.listRecipes(search, lastDocumentId, new CoroutineCallback<>((result, error) -> {
+ if (error != null) {
+ error.printStackTrace();
+ return;
+ }
+
+ if (result != null) {
+ for (Object document: result.getDocuments()) {
+ /* Extract JSON data from the response */
+ Map data = (Map) ((Document) document).getData();
+
+ /* Create recipe model from that JSON data */
+ RecipeModel recipe = new RecipeModel(data);
+
+ /* Add that model to our list of recipes */
+ recipes.add(recipe);
+ recipesDocuments.add((Document) document);
+ }
+
+ /* notify the adapter about the changes in list of recipes if list is changed */
+ if (result.getTotal() != 0) {
+ runOnUiThread(() -> arr.notifyDataSetChanged());
+ }
+ }
+ loading = false;
+ }));
+}
+```
+
+Now, in order to call ```loadNextPage``` every time user scrolls to the bottom, we will add an ```OnScrollListener``` to the listView in ```onCreate``` method.
+
+```
+listView.setOnScrollListener(new AbsListView.OnScrollListener() {
+ @Override
+ public void onScrollStateChanged(AbsListView absListView, int i) {}
+
+ @Override
+ public void onScroll(AbsListView absListView, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
+ /* Find out the last item which is visible on our UI */
+ int lastInScreen = firstVisibleItem + visibleItemCount;
+
+ if (lastInScreen == totalItemCount) { /* User is looking at the last item of our list, load next page if we aren't already loading. */
+ if (!loading) loadNextPage();
+ }
+ }
+});
+```
+
+Finally, get rid of the ```reloadList``` call from ```onCreate``` method, as our ```OnScrollListener``` will take care of it.
+
+Tada! That's all, we now have pagination implemented in our app!
\ No newline at end of file
diff --git a/src/routes/docs/tutorials/android/step-8/+page.markdoc b/src/routes/docs/tutorials/android/step-8/+page.markdoc
new file mode 100644
index 0000000000..335f57f5e9
--- /dev/null
+++ b/src/routes/docs/tutorials/android/step-8/+page.markdoc
@@ -0,0 +1,11 @@
+---
+layout: tutorial
+title: Next steps
+description: Learn to build an Android app with no backend code using an Appwrite backend.
+step: 8
+difficulty: beginner
+---
+
+# Test your project {% #test-your-project %}
+
+Run your project with **Run 'app'** button, or hit **Shift+F10** in Android Studio.
\ No newline at end of file
diff --git a/static/images/docs/tutorials/recipewrite-user-flow.png b/static/images/docs/tutorials/recipewrite-user-flow.png
new file mode 100644
index 0000000000000000000000000000000000000000..29ad697aefd67fc708d5a421724880b85bb6fcd6
GIT binary patch
literal 300040
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