Category: Java Android app development

Data storage is a very important part of Android development. There are various ways to store app data, including local databases, file systems, and cloud databases. In this tutorial, we will discuss storage using Firebase, a cloud service provided by Google. Firebase Storage offers a convenient way to store and manage images, videos, audio files, and more. In this tutorial, we will learn how to set up Firebase Storage and how to use it in an Android app.

What is Firebase?

Firebase is a mobile development platform provided by Google that offers various features, including databases, authentication, hosting, and storage. In particular, Firebase Storage is useful for storing and managing different types of files in the cloud. By using Firebase, you can easily manage data without having to operate a backend server.

Key Features

• Real-time database
• Cloud storage
• User authentication
• Analytics tools
• Hosting

Setting Up Firebase Storage

To use Firebase Storage, you first need to create a Firebase project and connect it to your Android app. Below are the steps to set up a Firebase project and integrate it into an Android app.

1. Create a Firebase Project

1. Access the Firebase console: Firebase Console.
2. Create a new project. Enter a project name and enable analytics if needed.
3. Once the project is created, go to “Project Settings.”

2. Add Android App

1. In the project settings page, click the “Add Application” button and select the Android icon.
2. Enter the package name for the app (e.g., com.example.myapp).
3. Enter the SHA-1 value of the app’s signing certificate. (Optional)
4. After registering the app, download the provided google-services.json file and add it to the app/ directory of your Android project.

3. Configure Gradle

You need to modify the build.gradle file to use the Firebase SDK.

build.gradle (Project level)
buildscript {
    dependencies {
        classpath 'com.google.gms:google-services:4.3.10' // Update to the latest version
    }
}

build.gradle (App level)
apply plugin: 'com.android.application'
apply plugin: 'com.google.gms.google-services'

dependencies {
    implementation 'com.google.firebase:firebase-storage:20.2.0' // Update to the latest version
}

Using Firebase Storage in Android App

Now that we have set up Firebase Storage, let’s learn how to upload and download files. The following example shows the code for a simple Android app that uploads and downloads images.

1. Implementing Image Upload Functionality

import android.content.Intent;
import android.graphics.Bitmap;
import android.net.Uri;
import android.os.Bundle;
import android.provider.MediaStore;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.Toast;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;

import com.google.android.gms.tasks.OnFailureListener;
import com.google.android.gms.tasks.OnSuccessListener;
import com.google.firebase.storage.FirebaseStorage;
import com.google.firebase.storage.StorageReference;

import java.io.IOException;

public class MainActivity extends AppCompatActivity {

    private static final int PICK_IMAGE_REQUEST = 1;
    private Uri imageUri;

    private ImageView imageView;
    private Button uploadButton;

    private FirebaseStorage firebaseStorage;
    private StorageReference storageReference;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        imageView = findViewById(R.id.image_view);
        uploadButton = findViewById(R.id.upload_button);

        firebaseStorage = FirebaseStorage.getInstance();
        storageReference = firebaseStorage.getReference("uploads");

        uploadButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                uploadImage();
            }
        });
        
        // Open image picker
        Intent intent = new Intent();
        intent.setType("image/*");
        intent.setAction(Intent.ACTION_GET_CONTENT);
        startActivityForResult(Intent.createChooser(intent, "Select Image"), PICK_IMAGE_REQUEST);
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (requestCode == PICK_IMAGE_REQUEST && resultCode == RESULT_OK && data != null && data.getData() != null) {
            imageUri = data.getData();
            try {
                Bitmap bitmap = MediaStore.Images.Media.getBitmap(getContentResolver(), imageUri);
                imageView.setImageBitmap(bitmap);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private void uploadImage() {
        if (imageUri != null) {
            StorageReference fileReference = storageReference.child(System.currentTimeMillis() + ".jpg");
            fileReference.putFile(imageUri)
                    .addOnSuccessListener(new OnSuccessListener() {
                        @Override
                        public void onSuccess(UploadTask.TaskSnapshot taskSnapshot) {
                            Toast.makeText(MainActivity.this, "Upload successful", Toast.LENGTH_SHORT).show();
                        }
                    })
                    .addOnFailureListener(new OnFailureListener() {
                        @Override
                        public void onFailure(@NonNull Exception e) {
                            Toast.makeText(MainActivity.this, e.getMessage(), Toast.LENGTH_SHORT).show();
                        }
                    });
        } else {
            Toast.makeText(this, "No image selected", Toast.LENGTH_SHORT).show();
        }
    }
}

2. Implementing Image Download Functionality

Let’s add a feature to download the uploaded images. The downloading process will be done by fetching the image via its URL and displaying it in an ImageView.

private void downloadImage(String imageUrl, ImageView imageView) {
    Glide.with(this)
            .load(imageUrl)
            .into(imageView);
}

// Example call
downloadImage("https://firebasestorage.googleapis.com/v0/b/your-app-id.appspot.com/o/uploads%2Fimage.jpg?alt=media", imageView);

Handling Errors During Image Upload

You can add error handling for various errors that may occur while uploading files to show error messages to the user. In the example, we will learn how to check the rules of Firebase Storage or verify network connectivity.

private void handleUploadError(Exception e) {
    if (e instanceof StorageException) {
        StorageException storageException = (StorageException) e;
        if (storageException.getErrorCode() == StorageException.ERROR_NOT_AUTHORIZED) {
            Toast.makeText(this, "Unauthorized access", Toast.LENGTH_SHORT).show();
        } else {
            Toast.makeText(this, "Error uploading image", Toast.LENGTH_SHORT).show();
        }
    } else {
        Toast.makeText(this, "Network error", Toast.LENGTH_SHORT).show();
    }
}

Conclusion

In this tutorial, we learned how to set up Firebase Storage and how to upload and download files in an Android app. Firebase provides a variety of cloud-based services, making it a great help for app development. Additionally, combining Firebase with authentication and database features can lead to the development of even more powerful apps. In the next session, we will explore the database features of Firebase.

References

• Firebase Storage – Getting Started with Android
• Firebase – Setting Up Android
• Firebase Storage API Reference

I hope this tutorial will be of great help in your Android app development!

Object-oriented programming (OOP) is a crucial concept in Android app development. This article will delve deeply into the principles of object-oriented programming, common mistakes, and how to solve these issues through Java code. This course provides useful information to help facilitate easy access to Android development. Each section includes example code for easier understanding.

1. What is Object-Oriented Programming (OOP)?

Object-oriented programming is one of the paradigms of software development that structures programs as independent units called objects, thereby modularizing the code and enhancing reusability. Java is an object-oriented language that supports OOP’s fundamental principles: encapsulation, inheritance, and polymorphism.

1.1 Fundamental Principles of OOP

• Encapsulation: This refers to bundling an object’s properties and methods into a single unit and protecting them from external access. This helps maintain data integrity.
• Inheritance: This is a method of defining new classes based on already defined classes. It increases code reusability and allows for extending functionality.
• Polymorphism: This is the ability for methods with the same name to behave in various forms. It increases the flexibility of programs.

2. The Dangers of Misusing Object-Oriented Programming

Failing to adhere to the fundamental principles of OOP can lead to decreased code readability and increased maintenance difficulty. Below are common mistakes that occur in OOP:

2.1 Unnecessary Information Exposure

If variables or methods are set as public and accessible externally, the object’s state may become unstable. To avoid these problems, methods to access variables should be established, preventing direct access.

Example Code:

public class User {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        }
    }
}

2.2 Inefficient Use of Inheritance

Abusing inheritance can complicate the code and lead to hard-to-track bugs. It is advisable to inherit classes only when necessary and to prefer ‘composition’ whenever possible.

Example Code:

public class Car {
    private Engine engine;

    public Car(Engine engine) {
        this.engine = engine;
    }

    public void start() {
        engine.start();
    }
}

public class Engine {
    public void start() {
        System.out.println("Engine started");
    }
}

2.3 Misuse of Polymorphism

When using polymorphism, it is important to understand the difference between method overloading and overriding. Moreover, the scope of polymorphism use must be clarified, as improper use can complicate the flow of code.

Example Code:

class Animal {
    void sound() {
        System.out.println("Animal sound");
    }
}

class Dog extends Animal {
    void sound() {
        System.out.println("Bark");
    }
}

class Cat extends Animal {
    void sound() {
        System.out.println("Meow");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myDog.sound();
        myCat.sound();
    }
}

3. SOLID Principles of Object-Oriented Design

The SOLID principles summarize five principles aimed at improving object-oriented design. By remembering and applying these principles, better applications can be designed.

3.1 Single Responsibility Principle (SRP)

A class should have only one responsibility, and that responsibility must be completely encapsulated. This increases the reusability of the class and makes changes easier.

3.2 Open-Closed Principle (OCP)

Software elements should be open for extension but closed for modification. This allows for adding new functionalities without changing existing code.

3.3 Liskov Substitution Principle (LSP)

Objects of a parent class should be replaceable with objects of a child class. This helps maintain system stability.

3.4 Interface Segregation Principle (ISP)

Clients should not depend on methods they do not use. This prevents the obligatory implementation of unnecessary functionalities.

3.5 Dependency Inversion Principle (DIP)

High-level modules should not depend on low-level modules; both should depend on abstractions. This reduces the coupling between modules.

4. Applying OOP in Android Applications

Now, let’s examine how to apply OOP principles in Android application development. We will create a simple example using the Android Studio IDE.

4.1 Project Setup

Create a new project in Android Studio and select a basic template. Then, set up the package structure as follows:

• com.example.myapp
• model
• view
• controller

4.2 Defining the Model

Create a model class that represents the data of the application. For example, you can define a User model.

Example Code:

package model;

public class User {
    private String name;

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

4.3 Defining the View

Create a view class that composes the user interface (UI). Utilize Android’s XML layouts to define the UI.

activity_main.xml Example:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Welcome" />

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Click Me" />
</LinearLayout>

4.4 Defining the Controller

Define a controller class that manages interactions between the UI and the model. Implement this functionality in the MainActivity.java file.

Example Code:

package controller;

import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;
import model.User;

public class MainActivity extends AppCompatActivity {
    private TextView textView;
    private Button button;
    private User user;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        textView = findViewById(R.id.textView);
        button = findViewById(R.id.button);
        user = new User("John Doe");

        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                textView.setText("Hello, " + user.getName());
            }
        });
    }
}

5. Conclusion

Object-oriented programming is a powerful paradigm essential for developing Android applications. The improper application of OOP principles can degrade code readability and maintainability; however, understanding and correctly applying OOP principles allows for the development of efficient and stable applications. This course addressed the fundamental concepts of OOP and common mistakes, and explored how to apply OOP through practical examples. Now you can develop better Android applications using Java and the principles of object-oriented programming.

Introduction

Android app development is an important task that handles various user interactions. In particular, touch and key events are fundamental ways for users to interact with the app. This article will detail how to handle touch and key events in Android apps using Java. We will provide characteristics of each event, processing methods, and practical tips along with usage examples.

1. Touch Events

Touch events occur when a user touches the screen with their finger. In Android, the OnTouchListener interface can be used to handle touch events. This event can detect various user actions, recognizing different gestures like swiping, long clicking, and double-clicking.

1.1 OnTouchListener Interface

The OnTouchListener interface is used to handle various touch events. It must implement the onTouch(View v, MotionEvent event) method. The MotionEvent argument of this method contains information about the user’s touch actions.

Touch Event Handling Example

    import android.app.Activity;
    import android.os.Bundle;
    import android.view.MotionEvent;
    import android.view.View;
    import android.widget.Toast;
    
    public class MainActivity extends Activity {
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            View touchView = findViewById(R.id.touch_view);
            touchView.setOnTouchListener(new View.OnTouchListener() {
                @Override
                public boolean onTouch(View v, MotionEvent event) {
                    switch (event.getAction()) {
                        case MotionEvent.ACTION_DOWN:
                            // Touch start
                            Toast.makeText(getApplicationContext(), "Touch Start", Toast.LENGTH_SHORT).show();
                            return true;
                        case MotionEvent.ACTION_MOVE:
                            // Touch move
                            Toast.makeText(getApplicationContext(), "Touch Move", Toast.LENGTH_SHORT).show();
                            return true;
                        case MotionEvent.ACTION_UP:
                            // Touch end
                            Toast.makeText(getApplicationContext(), "Touch End", Toast.LENGTH_SHORT).show();
                            return true;
                    }
                    return false;
                }
            });
        }
    }
    

In the example code above, when the user touches a view called touch_view, it detects the start, move, and end events and displays messages in a dialog.

1.2 GestureDetector Class

To recognize more complex gestures, you can use the GestureDetector class. This class helps to handle complex gestures such as swipes and double taps easily, in addition to simple touches.

Gesture Recognition Example

    import android.app.Activity;
    import android.os.Bundle;
    import android.view.GestureDetector;
    import android.view.MotionEvent;
    import android.view.View;
    import android.widget.Toast;
    
    public class MainActivity extends Activity {
        private GestureDetector gestureDetector;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            gestureDetector = new GestureDetector(this, new GestureDetector.SimpleOnGestureListener() {
                @Override
                public boolean onDoubleTap(MotionEvent e) {
                    Toast.makeText(getApplicationContext(), "Double Tap Detected", Toast.LENGTH_SHORT).show();
                    return super.onDoubleTap(e);
                }
    
                @Override
                public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
                    // Swipe gesture handling
                    Toast.makeText(getApplicationContext(), "Swipe Detected", Toast.LENGTH_SHORT).show();
                    return true;
                }
            });
    
            View gestureView = findViewById(R.id.gesture_view);
            gestureView.setOnTouchListener(new View.OnTouchListener() {
                @Override
                public boolean onTouch(View v, MotionEvent event) {
                    return gestureDetector.onTouchEvent(event);
                }
            });
        }
    }
    

The above code demonstrates how to recognize double taps and swipe gestures using the GestureDetector. Each gesture can notify the user with a Toast message.

2. Key Events

In Android apps, key events occur when a physical or virtual keyboard key is pressed. To handle key events, you can use the onKeyDown(int keyCode, KeyEvent event) and onKeyUp(int keyCode, KeyEvent event) methods.

2.1 onKeyDown and onKeyUp Methods

The onKeyDown method is called when a key is pressed, and the onKeyUp method is called when a key is released. You can override these methods to define reactions to specific key inputs.

Key Event Handling Example

    import android.app.Activity;
    import android.os.Bundle;
    import android.view.KeyEvent;
    import android.widget.Toast;
    
    public class MainActivity extends Activity {
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
        }
    
        @Override
        public boolean onKeyDown(int keyCode, KeyEvent event) {
            if (keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
                Toast.makeText(getApplicationContext(), "Volume Up Button Pressed", Toast.LENGTH_SHORT).show();
                return true; // Event consumed
            }
            return super.onKeyDown(keyCode, event);
        }

        @Override
        public boolean onKeyUp(int keyCode, KeyEvent event) {
            if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) {
                Toast.makeText(getApplicationContext(), "Volume Down Button Pressed", Toast.LENGTH_SHORT).show();
                return true; // Event consumed
            }
            return super.onKeyUp(keyCode, event);
        }
    }
    

The above example is configured to respond appropriately when the volume up and volume down buttons are pressed. It returns true to indicate that the event has been consumed.

2.2 Keyboard Input Handling

Android can also handle keyboard input. Typically, views like EditText are used to receive user input. This allows users to input characters, numbers, and symbols. To handle the input entered by the user in EditText, you can use TextWatcher along with OnKeyListener.

Keyboard Input Example

    import android.app.Activity;
    import android.os.Bundle;
    import android.text.Editable;
    import android.text.TextWatcher;
    import android.view.KeyEvent;
    import android.view.View;
    import android.widget.EditText;
    import android.widget.Toast;
    
    public class MainActivity extends Activity {
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            EditText editText = findViewById(R.id.edit_text);
            editText.setOnKeyListener(new View.OnKeyListener() {
                @Override
                public boolean onKey(View v, int keyCode, KeyEvent event) {
                    if (event.getAction() == KeyEvent.ACTION_DOWN && keyCode == KeyEvent.KEYCODE_ENTER) {
                        Toast.makeText(getApplicationContext(), "Enter Key Pressed", Toast.LENGTH_SHORT).show();
                        return true; // Event consumed
                    }
                    return false;
                }
            });
    
            editText.addTextChangedListener(new TextWatcher() {
                @Override
                public void beforeTextChanged(CharSequence s, int start, int count, int after) {
                }

                @Override
                public void onTextChanged(CharSequence s, int start, int before, int count) {
                    Toast.makeText(getApplicationContext(), "Text Changed: " + s, Toast.LENGTH_SHORT).show();
                }

                @Override
                public void afterTextChanged(Editable s) {
                }
            });
        }
    }
    

The above example detects input for the EditText and shows a Toast message when the user presses the enter key and when the text changes.

3. Conclusion

Touch and key events are essential elements that enable user interaction in Android app development. In this tutorial, we learned how to handle touch and key events. Throughout this process, we explored various techniques to improve interactions in the user interface using OnTouchListener, GestureDetector, onKeyDown/onKeyUp methods, TextWatcher, and more.

We encourage you to learn more about Android app development using Java. Experiment with and apply various methods to enhance user experience, creating richer applications!

Hello, everyone! Today, as part of the Android app development course using Java, we will learn in detail how to construct a tab layout. The tab layout helps make the user interface (UI) more intuitive and allows easy switching between various screens. In this tutorial, we will enhance our understanding of the basic structure of the tab layout, its various components, and practical examples using Java code.

What is a Tab Layout?

A tab layout is a UI component that allows users to switch between multiple screens or views using tab buttons. Users can easily navigate and access different information by clicking on the tab buttons. The Android tab layout is mainly implemented by combining TabLayout, ViewPager, and Fragment.

Basic Preparation for Implementing Tab Layout

To implement a tab layout, you need to create a new project using Android Studio. In this example, we will create a project that supports Android API 21 or higher as a basic requirement.

1. Run Android Studio and select “New Project”.
2. Choose “Empty Activity,” then enter the project name and package information on the next screen.
3. Finally, click the “Finish” button to create the project.

Gradle Setup

You need to add the necessary dependencies to the project’s build.gradle file.
Add the following code to the build.gradle (Module: app) file’s dependencies section.

implementation 'com.google.android.material:material:1.4.0'

Layout File Configuration

Let’s create the layout file required for configuring the tab layout. Open the res/layout/activity_main.xml file in your project and modify it as follows.

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <com.google.android.material.tabs.TabLayout
        android:id="@+id/tabLayout"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_alignParentTop="true"/>

    <androidx.viewpager.widget.ViewPager
        android:id="@+id/viewPager"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_below="@id/tabLayout"/>

</RelativeLayout>

Modifying MainActivity.java File

Open the MainActivity.java file and write the code to set up the tab layout and view pager.
Paste the code below into MainActivity.java.

import androidx.appcompat.app.AppCompatActivity;
    import androidx.fragment.app.Fragment;
    import androidx.fragment.app.FragmentPagerAdapter;
    import androidx.viewpager.widget.ViewPager;
    import com.google.android.material.tabs.TabLayout;
    import android.os.Bundle;

    public class MainActivity extends AppCompatActivity {

        ViewPager viewPager;
        TabLayout tabLayout;

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            viewPager = findViewById(R.id.viewPager);
            tabLayout = findViewById(R.id.tabLayout);

            setupViewPager(viewPager);
            tabLayout.setupWithViewPager(viewPager);
        }

        private void setupViewPager(ViewPager viewPager) {
            ViewPagerAdapter adapter = new ViewPagerAdapter(getSupportFragmentManager());
            adapter.addFragment(new FragmentOne(), "Tab 1");
            adapter.addFragment(new FragmentTwo(), "Tab 2");
            adapter.addFragment(new FragmentThree(), "Tab 3");
            viewPager.setAdapter(adapter);
        }
    }

Creating Fragments

Each tab consists of a Fragment. We will create FragmentOne, FragmentTwo, and FragmentThree.
Refer to the code below to create each Fragment file.

FragmentOne.java

import android.os.Bundle;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.ViewGroup;
    import androidx.fragment.app.Fragment;

    public class FragmentOne extends Fragment {

        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container,
                                 Bundle savedInstanceState) {
            // Inflate the layout for this fragment
            return inflater.inflate(R.layout.fragment_one, container, false);
        }
    }

FragmentTwo.java

import android.os.Bundle;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.ViewGroup;
    import androidx.fragment.app.Fragment;

    public class FragmentTwo extends Fragment {

        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container,
                                 Bundle savedInstanceState) {
            // Inflate the layout for this fragment
            return inflater.inflate(R.layout.fragment_two, container, false);
        }
    }

FragmentThree.java

import android.os.Bundle;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.ViewGroup;
    import androidx.fragment.app.Fragment;

    public class FragmentThree extends Fragment {

        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container,
                                 Bundle savedInstanceState) {
            // Inflate the layout for this fragment
            return inflater.inflate(R.layout.fragment_three, container, false);
        }
    }

Creating Fragment Layout Files

Create layout files for each Fragment. In the res/layout folder, create fragment_one.xml, fragment_two.xml, and fragment_three.xml files, and add the following content to each.

fragment_one.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Fragment 1"
        android:layout_centerInParent="true"/>

</RelativeLayout>

fragment_two.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Fragment 2"
        android:layout_centerInParent="true"/>

</RelativeLayout>

fragment_three.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Fragment 3"
        android:layout_centerInParent="true"/>

</RelativeLayout>

Creating ViewPagerAdapter Class

Create an adapter class that connects the ViewPager and the Fragments. Create a class named ViewPagerAdapter and write the following code.

import androidx.annotation.NonNull;
    import androidx.fragment.app.Fragment;
    import androidx.fragment.app.FragmentManager;
    import androidx.fragment.app.FragmentPagerAdapter;

    import java.util.ArrayList;
    import java.util.List;

    public class ViewPagerAdapter extends FragmentPagerAdapter {

        private final List<Fragment> fragmentList = new ArrayList<>();
        private final List<String> fragmentTitleList = new ArrayList<>();

        public ViewPagerAdapter(@NonNull FragmentManager fm) {
            super(fm);
        }

        @NonNull
        @Override
        public Fragment getItem(int position) {
            return fragmentList.get(position);
        }

        @Override
        public int getCount() {
            return fragmentList.size();
        }

        public void addFragment(Fragment fragment, String title) {
            fragmentList.add(fragment);
            fragmentTitleList.add(title);
        }

        @Override
        public CharSequence getPageTitle(int position) {
            return fragmentTitleList.get(position);
        }
    }

Run the App and Check Results

Once all the code is prepared, run the app in Android Studio.
When testing the app on an emulator or actual device, you will see three tab buttons, and clicking on each tab will display the corresponding Fragment.

Conclusion

So far, we have learned how to configure a tab layout in the Android app development course using Java.
Through this course, you have learned how to implement the tab layout, which is commonly used in Android UI design.
With this foundational knowledge, you can add more features to your projects and create apps that provide a better user experience!

If you have any questions or further inquiries, please leave a comment. I will continue to prepare many useful Android development courses in the future.
Thank you!

Hello! In this course, we will learn how to create a task management application on Android using Java. Task management apps provide various features necessary for managing and efficiently carrying out daily tasks. Through this course, we will learn about basic UI components, database management, user input handling, and how to implement complete functionality while running the app.

Table of Contents

• 1. Project Setup
• 2. UI Design
• 3. Database Configuration
• 4. Task Addition Functionality Implementation
• 5. Displaying Task List
• 6. Task Deletion and Modification Functions
• 7. App Optimization and Conclusion
• 8. Conclusion

1. Project Setup

Open Android Studio and create a new project. Select the “Empty Activity” template, set the project name and package name, and click the “Finish” button to create the project.

Once the project is created, you can add the necessary dependencies to Gradle to set up the database and UI-related libraries. Here is the code that needs to be added to the build.gradle file:

dependencies {
    implementation 'com.android.support:appcompat-v7:28.0.0'
    implementation 'androidx.room:room-runtime:2.3.0'
    annotationProcessor 'androidx.room:room-compiler:2.3.0'
}

2. UI Design

Now let’s design the UI. Open the res/layout/activity_main.xml file and add the following layout:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <EditText
        android:id="@+id/taskEditText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="Enter a new task"/>

    <Button
        android:id="@+id/addTaskButton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Add"/>

    <ListView
        android:id="@+id/taskListView"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1"/>

</LinearLayout>

3. Database Configuration

We set up the Room database to store task data. Create the entity class as follows:

import androidx.room.Entity;
import androidx.room.PrimaryKey;

@Entity
public class Task {
    @PrimaryKey(autoGenerate = true)
    private int id;
    private String description;

    public Task(String description) {
        this.description = description;
    }

    // Getter and Setter
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public String getDescription() { return description; }
    public void setDescription(String description) { this.description = description; }
}

Next, create the DAO interface:

import androidx.room.Dao;
import androidx.room.Insert;
import androidx.room.Query;
import java.util.List;

@Dao
public interface TaskDao {
    @Insert
    void insert(Task task);

    @Query("SELECT * FROM task")
    List getAllTasks();
}

Finally, create the database class:

import androidx.room.Database;
import androidx.room.Room;
import androidx.room.RoomDatabase;
import android.content.Context;

@Database(entities = {Task.class}, version = 1)
public abstract class AppDatabase extends RoomDatabase {
    public abstract TaskDao taskDao();

    private static AppDatabase INSTANCE;

    public static AppDatabase getDatabase(final Context context) {
        if (INSTANCE == null) {
            synchronized (AppDatabase.class) {
                if (INSTANCE == null) {
                    INSTANCE = Room.databaseBuilder(context.getApplicationContext(),
                            AppDatabase.class, "task_database")
                            .build();
                }
            }
        }
        return INSTANCE;
    }
}

4. Task Addition Functionality Implementation

In the Activity, we connect the UI elements and the database to implement the functionality to add tasks entered by the user. Open the MainActivity.java file and add the following code:

import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {
    private EditText taskEditText;
    private Button addTaskButton;
    private AppDatabase db;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        taskEditText = findViewById(R.id.taskEditText);
        addTaskButton = findViewById(R.id.addTaskButton);
        db = AppDatabase.getDatabase(this);

        addTaskButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String taskDescription = taskEditText.getText().toString();
                if (!taskDescription.isEmpty()) {
                    Task task = new Task(taskDescription);
                    new Thread(() -> db.taskDao().insert(task)).start();
                    taskEditText.setText("");
                }
            }
        });
    }
}

5. Displaying Task List

To display the list of tasks, we will use a ListView and an adapter. First, create a custom adapter class:

import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.TextView;
import java.util.List;

public class TaskAdapter extends ArrayAdapter {
    public TaskAdapter(Context context, List tasks) {
        super(context, 0, tasks);
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        Task task = getItem(position);
        if (convertView == null) {
            convertView = LayoutInflater.from(getContext()).inflate(android.R.layout.simple_list_item_1, parent, false);
        }

        TextView taskTextView = convertView.findViewById(android.R.id.text1);
        taskTextView.setText(task.getDescription());

        return convertView;
    }
}

Now set up the ListView in MainActivity.java:

import android.widget.ListView;
import androidx.lifecycle.Observer;
import androidx.lifecycle.ViewModelProvider;

public class MainActivity extends AppCompatActivity {
    // ...

    private ListView taskListView;
    private TaskAdapter taskAdapter;
    private List taskList;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        // ...
        
        taskListView = findViewById(R.id.taskListView);
        taskList = new ArrayList<>();
        taskAdapter = new TaskAdapter(this, taskList);
        taskListView.setAdapter(taskAdapter);

        loadTasks();
    }

    private void loadTasks() {
        new Thread(() -> {
            taskList.clear();
            taskList.addAll(db.taskDao().getAllTasks());
            runOnUiThread(() -> taskAdapter.notifyDataSetChanged());
        }).start();
    }
}

6. Task Deletion and Modification Functions

Add functionality to delete or modify each task by clicking on it. To add the functionality to delete a task, handle the click event of the ListView:

taskListView.setOnItemClickListener((parent, view, position, id) -> {
    Task task = taskList.get(position);
    new Thread(() -> {
        db.taskDao().delete(task); // Implement the delete method correctly
        taskList.remove(position);
        runOnUiThread(taskAdapter::notifyDataSetChanged);
    }).start();
});

The task modification feature can be implemented by adding a separate EditText and a Confirm button.

7. App Optimization and Conclusion

Test the app to fix bugs and find areas for improvement for optimization. Test on various devices to ensure that the layout works properly.

8. Conclusion

Through this course, we learned how to develop a task management app on Android using Java. We integrated the database and user interface components to implement basic CRUD (Create, Read, Update, Delete) functionality. Based on this project, feel free to add more features to create a more complete task management app.