Category: Java Android app development

In this post, we will take a detailed look at how to develop Android apps using Java and how to store data using Google Cloud Firestore.

1. What is Cloud Firestore?

Cloud Firestore is Google’s NoSQL cloud database that supports real-time data synchronization and offline capabilities. Firestore can scale horizontally and is also referred to as a real-time database. It can be easily used across various platforms and is particularly easy to integrate with mobile applications.

Firestore uses the concept of collections and documents for data storage. A collection contains multiple documents, and a document is a unit of data consisting of key-value pairs. This structure makes data modeling very flexible.

2. Key Features of Firestore

• Real-time data synchronization
• Offline support
• Data protection through security rules
• Scalability and flexibility
• Support for various languages and platforms

3. Setting Up Firestore

3.1. Creating a Firebase Project

The first step is to create a new project in the Firebase console. Follow the steps below:

1. Go to the Firebase website and log in.
2. Click the ‘Add Project’ button and enter the required information.
3. Firebase Analytics is optional, so set it up only if needed.
4. Once the project is created, navigate to the ‘Firestore Database’ menu and activate Firestore.
5. Set up security rules and choose the database mode.

3.2. Adding Firestore in Android Studio

After setting up the Firebase project, create a project in Android Studio. Use Gradle to add the necessary Firebase dependencies.


implementation "com.google.firebase:firebase-firestore-ktx:24.0.0"


You are now ready to initialize Firebase and use the Firestore instance.

Additionally, you need to add the google-services.json file to the app folder of your project to initialize Firebase. This file can be downloaded during the Firebase project creation.

You can initialize Firestore with the following code snippet:


FirebaseOptions options = new FirebaseOptions.Builder()
.setApplicationId("YOUR_APP_ID") // Required
.setApiKey("YOUR_API_KEY") // Required
.setDatabaseUrl("YOUR_DATABASE_URL") // Required
.setProjectId("YOUR_PROJECT_ID") // Required
.build();
FirebaseApp.initializeApp(context, options);


To get the Firestore instance, you can use the following code:


FirebaseFirestore db = FirebaseFirestore.getInstance();


4. Basic CRUD Operations in Firestore

Data handling in Firestore is carried out through the Create, Read, Update, Delete (CRUD) processes.

4.1. Adding Data (Create)

To add data, you can use the set or add methods.

The set method is used to explicitly create or update a document. The below example shows how to add user information to Firestore:


Map user = new HashMap<>();
user.put("first", "John");
user.put("last", "Doe");
user.put("age", 30);

db.collection("users").document("userID123")
.set(user)
.addOnSuccessListener(new OnSuccessListener() {
@Override
public void onSuccess(Void aVoid) {
Log.d(TAG, "DocumentSnapshot added with ID: " + "userID123");
}
})
.addOnFailureListener(new OnFailureListener() {
@Override
public void onFailure(@NonNull Exception e) {
Log.w(TAG, "Error adding document", e);
}
});


4.2. Reading Data (Read)

To read the data of a document, you can use the get method. Below is an example of reading the data of a specific document:


DocumentReference docRef = db.collection("users").document("userID123");
docRef.get().addOnCompleteListener(new OnCompleteListener() {
@Override
public void onComplete(@NonNull Task task) {
if (task.isSuccessful()) {
DocumentSnapshot document = task.getResult();
if (document.exists()) {
Log.d(TAG, "Document data: " + document.getData());
} else {
Log.d(TAG, "No such document");
}
} else {
Log.d(TAG, "get failed with ", task.getException());
}
}
});


4.3. Updating Data (Update)

To update an existing document, use the update method:


DocumentReference docRef = db.collection("users").document("userID123");
docRef.update("age", 31)
.addOnSuccessListener(new OnSuccessListener() {
@Override
public void onSuccess(Void aVoid) {
Log.d(TAG, "DocumentSnapshot successfully updated!");
}
})
.addOnFailureListener(new OnFailureListener() {
@Override
public void onFailure(@NonNull Exception e) {
Log.w(TAG, "Error updating document", e);
}
});


4.4. Deleting Data (Delete)

To delete a document, use the delete method:


db.collection("users").document("userID123")
.delete()
.addOnSuccessListener(new OnSuccessListener() {
@Override
public void onSuccess(Void aVoid) {
Log.d(TAG, "DocumentSnapshot successfully deleted!");
}
})
.addOnFailureListener(new OnFailureListener() {
@Override
public void onFailure(@NonNull Exception e) {
Log.w(TAG, "Error deleting document", e);
}
});


5. Firestore Real-time Database Functionality

One of the powerful features of Firestore is its real-time data synchronization capability. Below is how to receive real-time updates of data changes using Firestore listeners:


db.collection("users")
.document("userID123")
.addSnapshotListener(new EventListener() {
@Override
public void onEvent(@Nullable DocumentSnapshot documentSnapshot,
@Nullable FirebaseFirestoreException e) {
if (e != null) {
Log.w(TAG, "Listen failed.", e);
return;
}

if (documentSnapshot != null && documentSnapshot.exists()) {
Log.d(TAG, "Current data: " + documentSnapshot.getData());
} else {
Log.d(TAG, "Current data: null");
}
}
});


6. Setting Security Rules

You must set up security rules for Firestore to enhance the security of the database. By default, all users are granted read and write access to the data. You can manage user authentication and permissions by setting security rules.

For example, you can require user authentication and allow users to read or write only their own data. An example is as follows:


rules_version = '2';
service cloud.firestore {
match /databases/{database}/documents {
match /users/{userId} {
allow read, write: if request.auth != null && request.auth.uid == userId;
}
}
}


7. Conclusion

In this tutorial, we explored how to develop Android apps using Java and integrate with Cloud Firestore. Firestore offers various features and is used by many developers as a suitable data store for mobile applications.

The real-time data synchronization feature and offline support of Firestore are conducive to enhancing user experience. The security rules of Firebase also ensure the stability of data.

I hope this post helps you in your Android app development. If you have any further questions, please leave a comment!

One of the effective ways to share and access data in Android is through Content Providers. In this tutorial, we will explore the concept of Content Providers, how they work, and how to implement them in practice.

1. What is a Content Provider?

A Content Provider is a component that helps share and access data between Android applications. It can provide data from various data sources such as databases, files, and web services. This allows different apps to access or manipulate the same data. Content Providers use URIs (Uniform Resource Identifiers) to identify data and support CRUD (Create, Read, Update, Delete) operations on that data.

2. Structure of a Content Provider

A Content Provider is a class that belongs to Android’s component model and is typically implemented by inheriting from the ContentProvider class. Content Providers can override several methods to handle various data operations. The main methods are as follows:

• onCreate(): Called when the provider is first created. It performs setup tasks like database initialization.
• query(): Called when querying data from the database. The result is returned as a Cursor object.
• insert(): Called when adding new data to the database.
• update(): Called when modifying existing data.
• delete(): Called when deleting data.
• getType(): Returns the MIME type for a given URI.

3. Implementing a Content Provider

Now we will implement a Content Provider ourselves. In this example, we will create a Content Provider that handles simple contact data.

3.1. Defining the Database Model

We will use an SQLite database to store contact information. First, let’s define the Contact class and the database helper class.

java
public class Contact {
    public static final String TABLE_NAME = "contacts";
    public static final String COLUMN_ID = "_id";
    public static final String COLUMN_NAME = "name";
    public static final String COLUMN_PHONE = "phone";
}

java
public class DatabaseHelper extends SQLiteOpenHelper {
    private static final String DATABASE_NAME = "Contacts.db";
    private static final int DATABASE_VERSION = 1;

    public DatabaseHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        String CREATE_CONTACTS_TABLE = "CREATE TABLE " + Contact.TABLE_NAME + "("
                + Contact.COLUMN_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, "
                + Contact.COLUMN_NAME + " TEXT, "
                + Contact.COLUMN_PHONE + " TEXT" + ")";
        db.execSQL(CREATE_CONTACTS_TABLE);
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        db.execSQL("DROP TABLE IF EXISTS " + Contact.TABLE_NAME);
        onCreate(db);
    }
}

3.2. Defining the Content Provider Class

Now, we will write the Content Provider class. We will inherit from ContentProvider and override various methods.

java
public class ContactProvider extends ContentProvider {
    private static final String AUTHORITY = "com.example.contactprovider";
    private static final String BASE_PATH = "contacts";
    public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/" + BASE_PATH);

    private DatabaseHelper databaseHelper;

    @Override
    public boolean onCreate() {
        databaseHelper = new DatabaseHelper(getContext());
        return true;
    }

    @Override
    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
        SQLiteDatabase db = databaseHelper.getReadableDatabase();
        Cursor cursor = db.query(Contact.TABLE_NAME, projection, selection, selectionArgs, null, null, sortOrder);
        cursor.setNotificationUri(getContext().getContentResolver(), uri);
        return cursor;
    }

    @Override
    public Uri insert(Uri uri, ContentValues values) {
        SQLiteDatabase db = databaseHelper.getWritableDatabase();
        long id = db.insert(Contact.TABLE_NAME, null, values);
        getContext().getContentResolver().notifyChange(uri, null);
        return ContentUris.withAppendedId(CONTENT_URI, id);
    }

    @Override
    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
        SQLiteDatabase db = databaseHelper.getWritableDatabase();
        int rowsUpdated = db.update(Contact.TABLE_NAME, values, selection, selectionArgs);
        getContext().getContentResolver().notifyChange(uri, null);
        return rowsUpdated;
    }

    @Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
        SQLiteDatabase db = databaseHelper.getWritableDatabase();
        int rowsDeleted = db.delete(Contact.TABLE_NAME, selection, selectionArgs);
        getContext().getContentResolver().notifyChange(uri, null);
        return rowsDeleted;
    }

    @Override
    public String getType(Uri uri) {
        return "vnd.android.cursor.dir/vnd." + AUTHORITY + "." + BASE_PATH;
    }
}

3.3. Modifying the Manifest File

Register the Content Provider in the application’s manifest file.

<provider
    android:name=".ContactProvider"
    android:authorities="com.example.contactprovider"
    android:exported="true" />

4. Using the Content Provider

Now you can use the Content Provider in other parts of your app. Here is an example of adding and querying contacts.

java
// Adding a contact
ContentValues values = new ContentValues();
values.put(Contact.COLUMN_NAME, "John Doe");
values.put(Contact.COLUMN_PHONE, "010-1234-5678");
Uri newContactUri = getContentResolver().insert(ContactProvider.CONTENT_URI, values);

// Querying contacts
Cursor cursor = getContentResolver().query(ContactProvider.CONTENT_URI, null, null, null, null);
if (cursor != null && cursor.moveToFirst()) {
    do {
        String name = cursor.getString(cursor.getColumnIndex(Contact.COLUMN_NAME));
        String phone = cursor.getString(cursor.getColumnIndex(Contact.COLUMN_PHONE));
        Log.d("Contact", "Name: " + name + ", Phone: " + phone);
    } while (cursor.moveToNext());
    cursor.close();
}

5. Advantages and Disadvantages of Content Providers

The advantages and disadvantages of Content Providers are as follows.

Advantages

• Data Sharing: Easily share data between multiple apps.
• Standardization: Provides a standard API for CRUD operations, allowing for consistent code writing.
• Data Protection: Can finely control data access.

Disadvantages

• Complexity: Implementation can be relatively complex.
• Performance: Performance may degrade when handling large amounts of data.

6. Conclusion

Content Providers are a powerful tool for data sharing and access in Android. They allow for integration with other apps and effective data management. I hope this tutorial has helped you understand the concept and implementation of Content Providers. Now you can try using Content Providers in more complex app development.

In this course, we will develop an Android app using Java and implement the functionality to send notifications via KakaoTalk.
We plan to complete a feature that sends notifications to users when specific events occur using the KakaoTalk API.
This process will be explained based on Android Studio, and basic Android development knowledge is required.

Prerequisites

• Installation and setup of Java and Android SDK
• Installation of Android Studio
• Creation of a KakaoTalk developer account and app
• Verification of API Key and Secret Key

1. Android Studio Project Setup

Open Android Studio and create a new project. Select “Empty Activity” and complete the basic configuration before creating the project.

1.1 Gradle Setup

Next, open the build.gradle file of the app module and add the necessary libraries. We will be using Retrofit2 and Gson to utilize the KakaoTalk API.

dependencies {
    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
}

2. KakaoTalk API Integration

Create an application in the KakaoTalk Developer Center and verify the API Key. This key will be needed for future API calls.

2.1 Retrofit Setup

Add configuration to communicate with the API using Retrofit. Create a Retrofit instance and set up the necessary API interface.

public interface KakaoApi {
    @FormUrlEncoded
    @POST("/v2/api/talk/memo/default/send")
    Call sendMessage(@Header("Authorization") String token,
                                    @Field("template_object") String templateObject);
}

2.2 Implement Method for API Call

Implement a method to invoke the KakaoTalk API to send messages. OAuth authentication is required to authenticate the sender.

public class KakaoService {
    private static final String BASE_URL = "https://kapi.kakao.com";
    private KakaoApi kakaoApi;

    public KakaoService() {
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(BASE_URL)
                .addConverterFactory(GsonConverterFactory.create())
                .build();
        kakaoApi = retrofit.create(KakaoApi.class);
    }

    public void sendKakaoTalk(String accessToken, String message) {
        String jsonTemplate = "{\"object_type\":\"text\",\"text\":\"" + message + "\"}";
        Call call = kakaoApi.sendMessage("Bearer " + accessToken, jsonTemplate);
        call.enqueue(new Callback() {
            @Override
            public void onResponse(Call call, Response response) {
                if (response.isSuccessful()) {
                    Log.d("KakaoTalk", "Message sent successfully");
                } else {
                    Log.d("KakaoTalk", "Message sending failed: " + response.message());
                }
            }

            @Override
            public void onFailure(Call call, Throwable t) {
                Log.d("KakaoTalk", "Error occurred: " + t.getMessage());
            }
        });
    }
}

3. User Interface Implementation

Create a simple UI to receive input from the user. Use EditText and Button to implement the functionality to input and send messages.

<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/messageInput"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="Enter message"/>

    <Button
        android:id="@+id/sendButton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Send"/>

</LinearLayout>

3.1 Connect UI to Activity

Connect UI elements to the Activity to send a KakaoTalk message when the button is clicked.

public class MainActivity extends AppCompatActivity {
    private KakaoService kakaoService;
    private EditText messageInput;

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

        messageInput = findViewById(R.id.messageInput);
        Button sendButton = findViewById(R.id.sendButton);
        kakaoService = new KakaoService();

        sendButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String message = messageInput.getText().toString();
                String accessToken = "YOUR_ACCESS_TOKEN";  // Enter the access token here
                kakaoService.sendKakaoTalk(accessToken, message);
            }
        });
    }
}

4. Testing and Deployment

Run the app, enter a message, and click the ‘Send’ button to check if the message is sent via KakaoTalk.
If there are no issues, you can distribute it as an APK file for use on other devices.

Through this course, you have been able to implement a feature that directly sends notifications from an Android app using the KakaoTalk API.
Future additional features may include considering automating the sending of KakaoTalk messages by catching user phone notifications.
Create an app that communicates with more users through these features!

Hello! In this tutorial, we will introduce how to develop Android apps using Java. Specifically, through a project that creates a password confirmation screen similar to KakaoTalk, you will learn various concepts of Android development. This project includes everything from basic UI composition to data validation and event handling, providing you with a near-real experience.

Project Overview

The password confirmation screen requires users to input a password and provides a feature to verify it. This is an essential function in many applications, playing an important role in user authentication and information protection. Through this project, you will learn the following skills:

• Creating a new project in Android Studio
• UI design through XML layout files
• Connecting UI and logic using Java
• Password validation and user feedback handling

1. Setting Up the Development Environment

The first thing you need to do for Android app development is to set up the development environment. Download and install Android Studio to establish a basic development environment. After installation, create a new project. Name the project ‘PasswordCheckApp’ and select the ‘Empty Activity’ template.

2. Configuring the XML Layout

After creating the project, modify the ‘activity_main.xml’ file located in the ‘res/layout’ folder to design the user interface (UI).

<?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"
    android:padding="16dp">

    <TextView
        android:id="@+id/textViewTitle"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Password Confirmation"
        android:textSize="24sp"
        android:layout_centerHorizontal="true" 
        android:layout_marginBottom="24dp"/>

    <EditText
        android:id="@+id/editTextPassword"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="Enter your password"
        android:inputType="textPassword"/>

    <Button
        android:id="@+id/buttonConfirm"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Confirm"
        android:layout_below="@id/editTextPassword"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="16dp"/>

    <TextView
        android:id="@+id/textViewResult"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@id/buttonConfirm"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="16dp"
        android:textSize="16sp"/>
</RelativeLayout>

The above XML code creates a title, a password input field, a confirm button, and a TextView to display the result on the screen. Users can enter their passwords and check the results using this layout.

3. Implementing the Main Activity

After configuring the XML layout, let’s connect the UI and logic in the Java file. Open the ‘MainActivity.java’ file and write the following code:

package com.example.passwordcheckapp;

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

public class MainActivity extends AppCompatActivity {

    private EditText editTextPassword;
    private Button buttonConfirm;
    private TextView textViewResult;

    private static final String CORRECT_PASSWORD = "mypassword"; // Correct password

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

        editTextPassword = findViewById(R.id.editTextPassword);
        buttonConfirm = findViewById(R.id.buttonConfirm);
        textViewResult = findViewById(R.id.textViewResult);

        buttonConfirm.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                checkPassword();
            }
        });
    }

    private void checkPassword() {
        String inputPassword = editTextPassword.getText().toString();

        if (inputPassword.isEmpty()) {
            Toast.makeText(this, "Please enter your password.", Toast.LENGTH_SHORT).show();
            return;
        }

        if (inputPassword.equals(CORRECT_PASSWORD)) {
            textViewResult.setText("The password matches.");
        } else {
            textViewResult.setText("The password is incorrect.");
        }
    }
}

The above Java code implements a basic password verification logic. It compares the password entered by the user with the correct password and displays the result in the TextView. If the password is incorrect, the user is notified with a Toast message.

4. Running and Testing the Project

Once you have written the code, you can run the app on the Android Studio emulator or a real device. When the user enters the password and clicks the ‘Confirm’ button, it checks whether the password matches and displays the result on the screen.

5. Implementing Additional Features

The password confirmation screen provides basic functionality, but you can implement additional features to enhance the user experience. For example, you can add a feature to show or hide the password entered in the input field or implement a pattern lock method for password input.

Adding a Show/Hide Password Feature

Let’s add a feature that allows users to hide the password they entered. To do this, first, add an icon corresponding to the ‘EditText’, and implement a click event to show or hide the password.

<?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"
    android:padding="16dp">

    <TextView
        android:id="@+id/textViewTitle"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Password Confirmation"
        android:textSize="24sp"
        android:layout_centerHorizontal="true"
        android:layout_marginBottom="24dp"/>

    <EditText
        android:id="@+id/editTextPassword"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="Enter your password"
        android:inputType="textPassword"/>

    <ImageView
        android:id="@+id/imageViewTogglePassword"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_toRightOf="@id/editTextPassword"
        android:layout_marginStart="8dp"
        android:src="@drawable/ic_visibility_off"/>

    <Button
        android:id="@+id/buttonConfirm"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Confirm"
        android:layout_below="@id/editTextPassword"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="16dp"/>

    <TextView
        android:id="@+id/textViewResult"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@id/buttonConfirm"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="16dp"
        android:textSize="16sp"/>
</RelativeLayout>

You also need to modify the Java code to add the password visualization toggle function. Add the following code in ‘MainActivity.java’:

imageViewTogglePassword = findViewById(R.id.imageViewTogglePassword);

        imageViewTogglePassword.setOnClickListener(new View.OnClickListener() {
            boolean isPasswordVisible = false;

            @Override
            public void onClick(View v) {
                if (isPasswordVisible) {
                    editTextPassword.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);
                    imageViewTogglePassword.setImageResource(R.drawable.ic_visibility_off);
                } else {
                    editTextPassword.setInputType(InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD);
                    imageViewTogglePassword.setImageResource(R.drawable.ic_visibility);
                }
                isPasswordVisible = !isPasswordVisible;
                editTextPassword.setSelection(editTextPassword.length());
            }
        });

With the above code, we have set it up so that users can more conveniently enter their passwords. Now, clicking the icon will allow them to either show or hide the password.

Conclusion

Through this tutorial, you learned how to create a simple password confirmation screen using Java and Android. Since you learned about basic UI composition and handling user interactions, this will provide a good opportunity to expand the app by adding more complex features in the future. After practice, think about additional features and improvements, and trying them out is also a good way to learn.

Additionally, check out more resources and communities related to Android development, and challenge yourself with various projects. I hope this will help you in your Android development journey!

In Android app development, the integration of camera and gallery features is very consumer-friendly and is an essential functionality for many apps. In this tutorial, we will develop a simple camera and gallery integration app using Java. This app will allow users to take photos or select images from the gallery. Now, let’s look at the step-by-step process required to create this app.

1. Environment Setup

Install Android Studio and create a new project. When creating the project, select “Empty Activity” or “Basic Activity.” Choose Java as the language and click “Finish” to complete the project creation.

2. Request Necessary Permissions

You need to add the required permissions to the AndroidManifest.xml file to run the camera and gallery functions.

    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
              package="com.example.camera_gallery">
        <uses-permission android:name="android.permission.CAMERA"/>
        <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
        <application
            android:allowBackup="true"
            android:icon="@mipmap/ic_launcher"
            android:label="@string/app_name"
            android:roundIcon="@mipmap/ic_launcher_round"
            android:supportsRtl="true"
            android:theme="@style/Theme.AppCompat.Light.NoActionBar">
            <activity android:name=".MainActivity">
                <intent-filter>
                    <action android:name="android.intent.action.MAIN"/>
                    <category android:name="android.intent.category.LAUNCHER"/>
                </intent-filter>
            </activity>
        </application>
    </manifest>
    

3. UI Design

Design a simple user interface in the activity_main.xml file. Add two buttons and an ImageView to display the image.

    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent">
    
        <Button
            android:id="@+id/button_camera"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Take a Photo with Camera" 
            android:layout_centerHorizontal="true"
            android:layout_marginTop="50dp"/>
    
        <Button
            android:id="@+id/button_gallery"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Select from Gallery" 
            android:layout_below="@id/button_camera"
            android:layout_centerHorizontal="true"
            android:layout_marginTop="20dp"/>
    
        <ImageView
            android:id="@+id/image_view"
            android:layout_width="match_parent"
            android:layout_height="300dp"
            android:layout_below="@id/button_gallery"
            android:layout_marginTop="20dp"
            android:scaleType="centerCrop"/>
    
    </RelativeLayout>
    

4. Implement MainActivity.java

Now, write the MainActivity.java file to call the camera or gallery app based on button click events. First, set the click listeners for the buttons and implement the respective functionalities.

    package com.example.camera_gallery;

    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 androidx.annotation.Nullable;
    import androidx.appcompat.app.AppCompatActivity;

    public class MainActivity extends AppCompatActivity {
        private static final int CAMERA_REQUEST = 100;
        private static final int GALLERY_REQUEST = 200;
        
        private ImageView imageView;

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

            imageView = findViewById(R.id.image_view);
            Button buttonCamera = findViewById(R.id.button_camera);
            Button buttonGallery = findViewById(R.id.button_gallery);

            buttonCamera.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    Intent cameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                    startActivityForResult(cameraIntent, CAMERA_REQUEST);
                }
            });

            buttonGallery.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    Intent galleryIntent = new Intent(Intent.ACTION_PICK, MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
                    startActivityForResult(galleryIntent, GALLERY_REQUEST);
                }
            });
        }

        @Override
        protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
            super.onActivityResult(requestCode, resultCode, data);
            if (resultCode == RESULT_OK) {
                if (requestCode == CAMERA_REQUEST) {
                    Bundle extras = data.getExtras();
                    Bitmap imageBitmap = (Bitmap) extras.get("data");
                    imageView.setImageBitmap(imageBitmap);
                } else if (requestCode == GALLERY_REQUEST) {
                    Uri selectedImageUri = data.getData();
                    imageView.setImageURI(selectedImageUri);
                }
            }
        }
    }
    

5. Run and Test the App

Now that you’ve written all the code, run the app to test it. When you run the app on an emulator or a real smartphone, pressing the “Take a Photo with Camera” button will open the camera app, allowing you to take a photo and set it as the preview image. Pressing the “Select from Gallery” button allows you to choose an image from the gallery app and display it as a preview.

6. Conclusion

In this tutorial, we developed a simple Android app that integrates the camera and gallery using Java. This functionality is a fundamental skill that can be used in various Android apps, and you can build upon this to add more complex features tailored to individual needs. It is recommended to continue expanding on these foundational elements as you progress in Android development.

7. Additional Resources

• Android Developer – Camera
• Android Developer – Save files in internal storage
• Android Developer – Intent