개발공부

[Firebase] Realtime DataBase를 사용하기 위한 환경 설정

mscha — Fri, 16 Sep 2022 15:36:13 +0900

firebase의 Realtime DataBase를 사용하기 위해 환경 설정을 하는데 어려움을 겪었어서

제가 설정한 방법을 게시합니다.

firebase 콘솔에서 앱추가를 하여 google-services.json 파일을 받은 상태라고 가정하고 진행하겠습니다.

1. 안드로이드 스튜디오의 폴더 형식을 Project로 변경합니다.

2. 받은 google-serviecs.json 파일을 app 폴더 안에 넣습니다.

3. 프로젝트 수준 gradle 파일의 plugins에 아래 형식을 추가합니다.

plugins {
    id "com.google.gms.google-services" version "4.3.10" apply false
}

4. 모듈 수준 gradel 파일의 plugins와 dependencies에 아래 형식을 추가합니다.

plugins {
    id 'com.google.gms.google-services'
}

dependencies {
    implementation platform('com.google.firebase:firebase-bom:30.3.2')
    implementation 'com.google.firebase:firebase-analytics'
    implementation 'com.google.firebase:firebase-database'

    implementation 'commons-io:commons-io:2.4'
}
apply plugin: 'com.google.gms.google-services'

5. Sync를 누릅니다.

6. SDK Manager로 들어갑니다.

7. SDK Tools의 Google Play services를 체크 후 OK를 눌러 적용해줍니다.

Serverless Region(지역) 변경하기

mscha — Thu, 18 Aug 2022 14:38:01 +0900

서버리스로 배포한 프로젝트의 경로로가서 serverless.yml을 엽니다.

맨위의 이부분을 지우고

org: fullspringwater
app: aws-movie-server

아래 코드를 추가합니다.

console: true

그리고

provider 부분에 region 부분을 추가합니다.

provider:
  name: aws
  runtime: python3.8
  region: ap-northeast-2

그 후 deploy 해주시면 됩니다.

sls deploy

[Android] GPS 위도, 경도 정보 받기, 권한 설정

mscha — Fri, 29 Jul 2022 11:16:12 +0900

androidManifest.xml

아래 권한을 추가합니다.

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>

MainActivity.java

package com.fullspringwater.location;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AlertDialog;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;

import android.Manifest;
import android.content.ActivityNotFoundException;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.net.Uri;
import android.os.Bundle;
import android.provider.Settings;
import android.util.Log;
import android.widget.Toast;

public class MainActivity extends AppCompatActivity {

    LocationManager locationManager;
    LocationListener locationListener;

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

        locationManager = (LocationManager) this.getSystemService(LOCATION_SERVICE);
        locationListener = new LocationListener() {
            // 움직일 때 마다 location에 좌표정보를 담는다.
            @Override
            public void onLocationChanged(@NonNull Location location) {
                Log.i("myLocation", "위도 : " + location.getLatitude());
                Log.i("myLocation", "경도 : " + location.getLongitude());
            }
        };


        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(MainActivity.this,
                    new String[]{Manifest.permission.ACCESS_FINE_LOCATION,
                                Manifest.permission.ACCESS_COARSE_LOCATION},
                    100);
            return;
        }
        // LocationManager.GPS_PROVIDER
        // locationRequest : 어느 시간 주기로 이동을 감지할 것인지 (ms)
        // pendingIntent : 어느 거리만큼 이동했을 때 감지할 것인지 (m)
        // 조건을 사용하지 않으려면 -1로 지정한다.
        // 둘중 하나만 충족해도 update한다.
        locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER,
                3000,
                3,
                locationListener);
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);

        if(requestCode == 100){
            // 권한 설정 여부
            if (ActivityCompat.checkSelfPermission(MainActivity.this,
                    Manifest.permission.ACCESS_FINE_LOCATION) !=
                    PackageManager.PERMISSION_GRANTED &&
                    ActivityCompat.checkSelfPermission(MainActivity.this,
                            Manifest.permission.ACCESS_COARSE_LOCATION) !=
                                    PackageManager.PERMISSION_GRANTED) {
                // 권한 거부상태면 다이얼로그를 띄운다.
                AlertDialog.Builder localBuilder = new AlertDialog.Builder(this);
                localBuilder.setTitle("권한 설정")
                        .setMessage("권한을 설정하지 않으면 앱 사용이 불가능합니다.")
                        .setPositiveButton("권한 설정하러 가기", new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialogInterface, int i) {
                                try {
                                    Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
                                            .setData(Uri.parse("package:" + getPackageName()));
                                    startActivity(intent);
                                } catch (ActivityNotFoundException e){
                                    e.printStackTrace();
                                    Intent intent = new Intent(Settings.ACTION_MANAGE_APPLICATIONS_SETTINGS);
                                    startActivity(intent);
                                }
                            }
                        })
                        .setNegativeButton("종료하기", new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialogInterface, int i) {
//                                Toast.makeText(getApplication(), "제한됩니다.", Toast.LENGTH_SHORT).show();
                                finish();
                            }
                        }).create().show();


                return;
            }

            // LocationManager.GPS_PROVIDER
            // locationRequest : 어느 시간 주기로 이동을 감지할 것인지 (ms)
            // pendingIntent : 어느 거리만큼 이동했을 때 감지할 것인지 (m)
            // 조건을 사용하지 않으려면 -1로 지정한다.
            // 둘중 하나만 충족해도 update한다.
            locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER,
                    3000,
                    3,
                    locationListener);
        }
    }
}

실행화면

거부 눌렀을 때

권한 설정하기 눌렀을 때

여기서 권한 허용이 가능합니다.

권한 허용 후 로그캣

[Android] Retrofit2 라이브러리 form-data 형식 파일, 텍스트 전송하기(Multipart form 이용)

mscha — Tue, 26 Jul 2022 10:23:09 +0900

아래와 같이 Heder로는 Authorization.

Body로는 form-data 형식의 key - value로 되어있는

File과 Text를 옮기는 방법을 알아보겠습니다.

결과

예제로는 이미지와 텍스트를 올리는 것으로 하겠습니다.

API 인터페이스

PostingApi

// 파일을 알아서 쪼개서 보내줌 @Multipart
@Multipart
@POST("/posting")
Call<PostingRes> addPosting(@Header("Authorization") String AccessToken,
                            @Part MultipartBody.Part photo,
                            @Part("content")RequestBody content);

PostingRes

public class PostingRes {
    private String result;


    public String getResult() {
        return result;
    }

    public void setResult(String result) {
        this.result = result;
    }
   
}

호출 부분

AddActivity

Retrofit retrofit = NetworkClient.getRetrofitClient(AddActivity.this);
PostingApi api = retrofit.create(PostingApi.class);

// 멀티파트로 파일을 보내는 경우, 파일 파라미터 만드는 방법
RequestBody fileBody = RequestBody.create(photoFile, MediaType.parse("image/*"));
// 키값, 파일명, 실제 파일
MultipartBody.Part photo = MultipartBody.Part.createFormData("photo",
        photoFile.getName(), fileBody);

// 멀티파트로 form-data형식 text 보내는 경우
RequestBody contentBody = RequestBody.create("보낼 텍스트", MediaType.parse("text/plain"));

// 헤더에 들어갈 억세스토큰 가져온다.
SharedPreferences sp = getApplication()
        .getSharedPreferences(Config.PREFERENCES_NAME, MODE_PRIVATE);
String accessToken = sp.getString("accessToken", "");


Call<PostingRes> call = api.addPosting("Bearer " + accessToken, photo, contentBody);


call.enqueue(new Callback<PostingRes>() {
    @Override
    public void onResponse(Call<PostingRes> call, Response<PostingRes> response) {
       
        if(response.isSuccessful()){
            Toast.makeText(AddActivity.this, "포스팅 완료", Toast.LENGTH_SHORT).show();
            finish();
        }else {
            Toast.makeText(AddActivity.this, "에러발생 : " + response.code(),
                    Toast.LENGTH_SHORT).show();
        }
    }

    @Override
    public void onFailure(Call<PostingRes> call, Throwable t) {
     
        // 네트워크 자체 문제로 실패
        Toast.makeText(AddActivity.this, "네트워크에 문제가 있습니다.", Toast.LENGTH_SHORT).show();
    }
});

이때 photoFile은 아래 게시글의 과정을 통해 얻어온 File형식의 변수입니다.

[Android] 카메라 / 앨범 처리

build.gradle 아래 코드를 추가합니다. dependencies { implementation 'commons-io:commons-io:2.4' } res/xml 경로 fileprovider.xml 파일을 생성합니다. fileprovider.xml <?xml version="1.0" encoding="utf-..

mscha.tistory.com

[Android] Progress Dialog 프로그레스 다이얼로그 생성/제거

mscha — Mon, 25 Jul 2022 09:49:06 +0900

변수 선언

// 네트워크 처리 보여주는 프로그레스 다이얼로그
    ProgressDialog dialog;

함수 정의

void showProgress(String message){
        dialog = new ProgressDialog(this);
        dialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
        dialog.setMessage(message);
        dialog.show();
    }

    void dismissProgress(){
        dialog.dismiss();
    }

사용하기

생성

showProgress("보여줄 텍스트");

제거

dismissProgress();

[Android] Retrofit2 라이브러리를 이용한 POST로 API 호출하여 처리하는 방법

mscha — Thu, 21 Jul 2022 17:50:29 +0900

retrofit2 라이브러리 사용하기 전

기본적인 설정 방법은 아래 링크에 있습니다.

https://mscha.tistory.com/238

[Android] Retrofit2 라이브러리 사용을 위한 설정 방법

build.gradle 아래 코드를 추가합니다. dependencies { implementation 'com.squareup.retrofit2:retrofit:2.9.0' implementation 'com.squareup.retrofit2:converter-gson:2.9.0' implementation("com.squareup.o..

mscha.tistory.com

저는 POST 메소드로 api의 body에 아래와 같은식으로 데이터를 주면

{
    "email": "test9@naver.com",
    "password": "1234",
    "nickname": "김동주"
}

아래와 같은 식으로 결과가 나오는 api를 가지고 테스트 해보겠습니다.

{
    "result": "success",
    "access_token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJmcmVzaCI6ZmFsc2UsImlhdCI6MTY1ODM4NzA0NiwianRpIjoiNGVmNGNiMGQtNTVjMC00MjVlLWI4YzYtNzg1N2RjYWFiNWQxIiwidHlwZSI6ImFjY2VzcyIsInN1YiI6MTAsIm5iZiI6MTY1ODM4NzA0Nn0.YVCP9wcN1rnNh_4OUTNnT4-aPbG15_bwe7drwHkO4xQ",
}

기본적으로 아래와 같은 식의 구성을 만들어 줍니다.

1.회원가입 화면 만들기

activity_register.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout 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=".RegisterActivity">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_margin="10dp"
        android:orientation="vertical"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent">

        <TextView
            android:id="@+id/textView"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_marginTop="30dp"
            android:gravity="center"
            android:text="회원가입"
            android:textSize="28sp" />

        <EditText
            android:id="@+id/editEmail"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_marginTop="30dp"
            android:ems="10"
            android:hint="이메일"
            android:inputType="textPersonName"
            android:textSize="28sp" />

        <EditText
            android:id="@+id/editPassword"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:ems="10"
            android:hint="비밀번호"
            android:inputType="textPersonName"
            android:textSize="28sp" />

        <EditText
            android:id="@+id/editNickname"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:ems="10"
            android:hint="닉네임"
            android:inputType="textPersonName"
            android:textSize="28sp" />

        <Button
            android:id="@+id/btnRegister"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_marginTop="50dp"
            android:text="회원가입"
            android:textSize="28sp" />
    </LinearLayout>
</androidx.constraintlayout.widget.ConstraintLayout>

2. model/User

회원가입과 관련있는 데이터는 User이기 때문에 User 클래스를 만들어줍니다.

package com.fullspringwater.memo.model;

import java.io.Serializable;

public class User implements Serializable {
    private String email;
    private String password;
    private String nickname;

    public User(String email, String password, String nickname) {
        this.email = email;
        this.password = password;
        this.nickname = nickname;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }
}

3. model/RegisterRes

package com.fullspringwater.memo.model;

import java.io.Serializable;

public class RegisterRes implements Serializable {
    private String result;
    private String accessToken;

    public String getResult() {
        return result;
    }

    public void setResult(String result) {
        this.result = result;
    }

    public String getAccessToken() {
        return accessToken;
    }

    public void setAccessToken(String accessToken) {
        this.accessToken = accessToken;
    }
}

4. config/Config

package com.fullspringwater.memo.config;

public class Config {

    public static final String BASE_URL = "URL주소";
    public static final String TEST_URL = "TEST_URL 주소";
    public static final String PREFERENCES_NAME = "memo_app";
}

5. api/UserApi

@POST("/users/register")

: BASE_URL의 뒤에 오는 경로와 메소드를 지정해줍니다.

Call<RegisterRes> register(@Body User user)

: Body에 user 객체를 넘겨주고 반환은 RegisterRes 클래스의 형태로 줍니다.

package com.fullspringwater.memo.api;

import com.fullspringwater.memo.model.RegisterRes;
import com.fullspringwater.memo.model.User;

import retrofit2.Call;
import retrofit2.http.Body;
import retrofit2.http.POST;

public interface UserApi {

    @POST("/users/register")
    Call<RegisterRes> register(@Body User user);
}

6. api/NetworkClient

네트워크 통신할 retrofit 객체를 반환하는 역할을 합니다.

package com.fullspringwater.memo.api;

import android.content.Context;

import com.fullspringwater.memo.config.Config;

import java.util.concurrent.TimeUnit;

import okhttp3.OkHttpClient;
import okhttp3.logging.HttpLoggingInterceptor;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;

public class NetworkClient {

    public static Retrofit retrofit;

    public static Retrofit getRetrofitClient(Context context){
        if(retrofit == null){
            HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
            loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BASIC);

            OkHttpClient httpClient = new OkHttpClient.Builder()
                    .connectTimeout(1, TimeUnit.MINUTES)
                    .readTimeout(1, TimeUnit.MINUTES)
                    .writeTimeout(1, TimeUnit.MINUTES)
                    .addInterceptor(loggingInterceptor)
                    .build();

            retrofit = new Retrofit.Builder().baseUrl(Config.BASE_URL)
                    .client(httpClient)
                    // 데이터를 주고 받을 때 클래스로 처리하겠다.
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();
        }
        return retrofit;
    }
}

7. MainActivity

package com.fullspringwater.memo;

import androidx.appcompat.app.AppCompatActivity;

import android.content.Intent;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;

import com.fullspringwater.memo.config.Config;

public class MainActivity extends AppCompatActivity {


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

        // 1. 쉐어드 프리퍼런스에서 억세스토큰을 가져온다.
        SharedPreferences sp = getApplication()
                .getSharedPreferences(Config.PREFERENCES_NAME, MODE_PRIVATE);
        String accessToken = sp.getString("accessToken", "");

        // 2. 만약 억세스토큰이 없으면, 회원가입 액티비티를 실행하고,
        //    그렇지 않으면, 메모가져오는 API 호출해서, 리사이클러뷰로 화면에
        //    내 메모 보여준다.
        if(accessToken.isEmpty()){
            Intent intent = new Intent(MainActivity.this, RegisterActivity.class);
            startActivity(intent);
        }else{
            // todo : 내 메모 가져오는 api 호출
        }



    }
}

8. RegisterActivity

package com.fullspringwater.memo;

import androidx.appcompat.app.AppCompatActivity;

import android.app.ProgressDialog;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;

import com.fullspringwater.memo.api.NetworkClient;
import com.fullspringwater.memo.api.UserApi;
import com.fullspringwater.memo.config.Config;
import com.fullspringwater.memo.model.RegisterRes;
import com.fullspringwater.memo.model.User;

import java.util.regex.Pattern;

import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import retrofit2.Retrofit;

public class RegisterActivity extends AppCompatActivity {
    EditText editEmail;
    EditText editPassword;
    EditText editNickName;
    Button btnRegister;

    // 네트워크 처리 보여주는 프로그레스 다이얼로그
    ProgressDialog dialog;

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

        editEmail = findViewById(R.id.editEmail);
        editPassword = findViewById(R.id.editPassword);
        editNickName = findViewById(R.id.editNickname);
        btnRegister = findViewById(R.id.btnRegister);
        btnRegister.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                // 이메일 가져온다. 이메일 형식체크
                String email = editEmail.getText().toString().trim();
                Pattern pattern = android.util.Patterns.EMAIL_ADDRESS;
                if(pattern.matcher(email).matches() == false){
                    Toast.makeText(RegisterActivity.this
                            , "이메일 형식이 올바르지 않습니다."
                            , Toast.LENGTH_SHORT).show();
                    return;
                }

                // 비밀번호 가져온다.
                String password = editPassword.getText().toString().trim();

                // 비밀번호 길이 체크
                if(password.length() < 4 || password.length() > 12){
                    Toast.makeText(RegisterActivity.this
                            , "비밀번호 길이는 4자 이상, 12자 이하로 만들어주세요."
                            , Toast.LENGTH_SHORT).show();
                    return;
                }

                // 닉네임을 가져와서, 빈 문자열인지만 체크
                String nickname = editNickName.getText().toString().trim();
                if(nickname.isEmpty()){
                    Toast.makeText(RegisterActivity.this, "닉네임 입력하세요.",
                            Toast.LENGTH_SHORT).show();
                    return;
                }

                // 이 데이터를 API로 호출
                // 네트워크 통해서 데이터를 보내고 있다는,
                // 프로그레스 다이얼로그를 먼저 띄운다.
                showProgress(getString(R.string.dialog_register));

                Retrofit retrofit = NetworkClient.getRetrofitClient(RegisterActivity.this);

                UserApi api = retrofit.create(UserApi.class);

                User user = new User(email, password, nickname);

                Call<RegisterRes> call = api.register(user);
                // 실제 api 호출
                call.enqueue(new Callback<RegisterRes>() {
                    @Override
                    public void onResponse(Call<RegisterRes> call, Response<RegisterRes> response) {
                        dismissProgress();

                        // 200 OK
                        if(response.isSuccessful()){
                            RegisterRes registerRes = response.body();

                            // 억세스토큰은, 이제 앱에서 api 호출할 때마다 헤더에 넣어서 보내야 한다.
                            // 따라서 억세스토큰은, 쉐어드 프리퍼런스에 저장해 놓는다.
                            SharedPreferences sp = getApplication().getSharedPreferences(Config.PREFERENCES_NAME, MODE_PRIVATE);
                            SharedPreferences.Editor editor = sp.edit();
                            editor.putString("accessToken", registerRes.getAccessToken());
                            editor.apply();

                            finish();

                        } else if(response.code() == 400){

                        } else{
                            Toast.makeText(RegisterActivity.this, "에러발생 : " + response.code(),
                                    Toast.LENGTH_SHORT).show();
                        }
                    }

                    @Override
                    public void onFailure(Call<RegisterRes> call, Throwable t) {
                        // 네트워크 자체 문제로 실패
                        dismissProgress();
                    }
                });




            }
        });
    }
    void showProgress(String message){
        dialog = new ProgressDialog(this);
        dialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
        dialog.setMessage(message);
        dialog.show();
    }

    void dismissProgress(){
        dialog.dismiss();
    }
}

실행화면

해당 api의 데이터베이스에 추가된 모습

[Android] Retrofit2 라이브러리 사용을 위한 설정 방법

mscha — Thu, 21 Jul 2022 17:30:05 +0900

build.gradle

아래 코드를 추가합니다.

dependencies {
    
    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
    implementation("com.squareup.okhttp3:logging-interceptor:4.9.0")

}

res/xml

network_security_config.xml

<?xml version="1.0" encoding="utf-8" ?>

<network-security-config>
    <domain-config cleartextTrafficPermitted="false">
        <domain includeSubdomains="true">*.허용할 도메인</domain>
    </domain-config>
</network-security-config>

AndroidMenifest.xml

아래 코드를 추가합니다.

android:targetSandboxVersion="1"

<uses-permission android:name="android.permission.INTERNET"/>

android:networkSecurityConfig="@xml/network_security_config"
android:usesCleartextTraffic="true"

예시

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    package="com.fullspringwater.memo"
    android:targetSandboxVersion="1">

    <uses-permission android:name="android.permission.INTERNET"/>



    <application
        android:networkSecurityConfig="@xml/network_security_config"
        android:usesCleartextTraffic="true"
        android:allowBackup="true"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.Memo"
        tools:targetApi="31">
        <activity
            android:name=".RegisterActivity"
            android:exported="false" />
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

[Android] 카메라 / 앨범 처리

mscha — Thu, 21 Jul 2022 14:56:13 +0900

build.gradle

아래 코드를 추가합니다.

dependencies {

    implementation 'commons-io:commons-io:2.4'
}

res/xml 경로

fileprovider.xml 파일을 생성합니다.

fileprovider.xml

<?xml version="1.0" encoding="utf-8"?>
<paths>
    <root-path
        name="root"
        path="." />

    <cache-path
        name="cache"
        path="." /> <!--Context.getCacheDir() 내부 저장소-->
    <files-path
        name="files"
        path="." /> <!--Context.getFilesDir() 내부 저장소-->

    <external-path
        name="external"
        path="."/>  <!--  Environment.getExternalStorageDirectory() 외부 저장소-->
    <external-cache-path
        name="external-cache"
        path="."/> <!--  Context.getExternalCacheDir() 외부 저장소-->
    <external-files-path
        name="images"
        path="Pictures" /> <!--  Context.getExternalFilesDir() 외부 저장소-->
</paths>

AndroidMenifest.xml

아래 코드들을 추가해줍니다.

<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.CAMERA"/>

<application
    android:requestLegacyExternalStorage="true"
    >

<provider
    android:authorities="패키지명.fileprovider"
    android:name="androidx.core.content.FileProvider"
    android:exported="false"
    android:grantUriPermissions="true">
    <meta-data
        android:name="android.support.FILE_PROVIDER_PATHS"
        android:resource="@xml/fileprovider"/>
</provider>

예시

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    package="com.fullspringwater.camera">

    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.CAMERA"/>


    <application
        android:requestLegacyExternalStorage="true"
        android:allowBackup="true"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.Camera"
        tools:targetApi="31">

        <provider
            android:authorities="com.fullspringwater.camera.fileprovider"
            android:name="androidx.core.content.FileProvider"
            android:exported="false"
            android:grantUriPermissions="true">
            <meta-data
                android:name="android.support.FILE_PROVIDER_PATHS"
                android:resource="@xml/fileprovider"/>
        </provider>

        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

버튼을 누르면 카메라로 사진을 찍을 것인지,

앨범에서 사진을 가져올 것인지를 선택하는 기능을 구현 해보겠습니다.

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout 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">


    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent">

        <Button
            android:id="@+id/button"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_marginLeft="10dp"
            android:layout_marginTop="30dp"
            android:layout_marginRight="10dp"
            android:layout_marginBottom="30dp"
            android:text="사진"
            android:textSize="30sp" />

        <ImageView
            android:id="@+id/imageView"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            app:srcCompat="@drawable/ic_launcher_foreground" />
    </LinearLayout>
</androidx.constraintlayout.widget.ConstraintLayout>

MainActivity.java

아래와 같이 되어있는 코드 부분은 본인의 패키지명으로 바꿔주셔야 합니다.

com.fullspringwater.camera.fileprovider

패키지명.fileprovider

package com.fullspringwater.camera;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AlertDialog;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import androidx.core.content.FileProvider;

import android.Manifest;
import android.annotation.SuppressLint;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.media.ExifInterface;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Environment;
import android.os.ParcelFileDescriptor;
import android.provider.MediaStore;
import android.provider.OpenableColumns;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.Toast;

import org.apache.commons.io.IOUtils;

import java.io.File;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.text.SimpleDateFormat;
import java.util.Date;

public class MainActivity extends AppCompatActivity {

    Button button;
    ImageView imageView;
    private File photoFile;

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

        button = findViewById(R.id.button);
        imageView = findViewById(R.id.imageView);

        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                // 버튼을 누르면 카메라와 앨범 어떤 것을 선택할 것인지
                // 알러트 다이얼로그를 띄운다.
                showDialog();
                // 카메라를 선택하면, 사진찍는 것으로,
                // 앨범을 선택하면, 앨범에서 사진 선택할 수 있도록 하고

                // 그 결과는 이미지 뷰에 보여주도록 개발.

            }
        });

    }

    // 알러트 다이얼로그 띄우는 함수
    void showDialog(){
        AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);
        builder.setTitle(R.string.alert_title);
        builder.setItems(R.array.alert_photo, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialogInterface, int i) {
                if(i == 0){
                    // 사진 찍는 코드 실행
                    camera();
                }else{
                    // 앨범에서 사진 가져오는 코드 실행
                    album();
                }
            }
        });
        AlertDialog alertDialog = builder.create();
        alertDialog.show();
    }
    
    private void camera(){
        int permissionCheck = ContextCompat.checkSelfPermission(
                MainActivity.this, Manifest.permission.CAMERA);

        if(permissionCheck != PackageManager.PERMISSION_GRANTED){
            ActivityCompat.requestPermissions(MainActivity.this,
                    new String[]{Manifest.permission.CAMERA} ,
                    1000);
            Toast.makeText(MainActivity.this, "카메라 권한 필요합니다.",
                    Toast.LENGTH_SHORT).show();
            return;
        } else {
            Intent i = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
            if(i.resolveActivity(MainActivity.this.getPackageManager())  != null  ){

                // 사진의 파일명을 만들기
                String fileName = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
                photoFile = getPhotoFile(fileName);

                Uri fileProvider = FileProvider.getUriForFile(MainActivity.this,
                        "com.fullspringwater.camera.fileprovider", photoFile);
                i.putExtra(MediaStore.EXTRA_OUTPUT, fileProvider);
                startActivityForResult(i, 100);

            } else{
                Toast.makeText(MainActivity.this, "이폰에는 카메라 앱이 없습니다.",
                        Toast.LENGTH_SHORT).show();
            }
        }


    }
    private File getPhotoFile(String fileName) {
        File storageDirectory = getExternalFilesDir(Environment.DIRECTORY_PICTURES);
        try{
            return File.createTempFile(fileName, ".jpg", storageDirectory);
        }catch (IOException e){
            e.printStackTrace();
            return null;
        }
    }

    private void album(){
        if(checkPermission()){
            displayFileChoose();
        }else{
            requestPermission();
        }
    }
    private void requestPermission() {
        if(ActivityCompat.shouldShowRequestPermissionRationale(MainActivity.this,
                Manifest.permission.WRITE_EXTERNAL_STORAGE)){
            Toast.makeText(MainActivity.this, "권한 수락이 필요합니다.",
                    Toast.LENGTH_SHORT).show();
        }else{
            ActivityCompat.requestPermissions(MainActivity.this,
                    new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, 500);
        }
    }

    private boolean checkPermission(){
        int result = ContextCompat.checkSelfPermission(MainActivity.this,
                Manifest.permission.WRITE_EXTERNAL_STORAGE);
        if(result == PackageManager.PERMISSION_DENIED){
            return false;
        }else{
            return true;
        }
    }

    private void displayFileChoose() {
        Intent i = new Intent();
        i.setType("image/*");
        i.setAction(Intent.ACTION_GET_CONTENT);
        startActivityForResult(Intent.createChooser(i, "SELECT IMAGE"), 300);
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch (requestCode) {
            case 1000: {
                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    Toast.makeText(MainActivity.this, "권한 허가 되었음",
                            Toast.LENGTH_SHORT).show();
                } else {
                    Toast.makeText(MainActivity.this, "아직 승인하지 않았음",
                            Toast.LENGTH_SHORT).show();
                }
                break;
            }
            case 500: {
                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    Toast.makeText(MainActivity.this, "권한 허가 되었음",
                            Toast.LENGTH_SHORT).show();
                } else {
                    Toast.makeText(MainActivity.this, "아직 승인하지 않았음",
                            Toast.LENGTH_SHORT).show();
                }

            }

        }
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
        if(requestCode == 100 && resultCode == RESULT_OK){

            Bitmap photo = BitmapFactory.decodeFile(photoFile.getAbsolutePath());

            ExifInterface exif = null;
            try {
                exif = new ExifInterface(photoFile.getAbsolutePath());
            } catch (IOException e) {
                e.printStackTrace();
            }
            int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION,
                    ExifInterface.ORIENTATION_UNDEFINED);
            photo = rotateBitmap(photo, orientation);

            // 압축시킨다. 해상도 낮춰서
            OutputStream os;
            try {
                os = new FileOutputStream(photoFile);
                photo.compress(Bitmap.CompressFormat.JPEG, 50, os);
                os.flush();
                os.close();
            } catch (Exception e) {
                Log.e(getClass().getSimpleName(), "Error writing bitmap", e);
            }

            photo = BitmapFactory.decodeFile(photoFile.getAbsolutePath());

            imageView.setImageBitmap(photo);
            imageView.setScaleType(ImageView.ScaleType.CENTER_INSIDE);

            // 네트워크로 데이터 보낸다.


        }else if(requestCode == 300 && resultCode == RESULT_OK && data != null &&
                data.getData() != null){

            Uri albumUri = data.getData( );
            String fileName = getFileName( albumUri );
            try {

                ParcelFileDescriptor parcelFileDescriptor = getContentResolver( ).openFileDescriptor( albumUri, "r" );
                if ( parcelFileDescriptor == null ) return;
                FileInputStream inputStream = new FileInputStream( parcelFileDescriptor.getFileDescriptor( ) );
                photoFile = new File( this.getCacheDir( ), fileName );
                FileOutputStream outputStream = new FileOutputStream( photoFile );
                IOUtils.copy( inputStream, outputStream );

//                //임시파일 생성
//                File file = createImgCacheFile( );
//                String cacheFilePath = file.getAbsolutePath( );


                // 압축시킨다. 해상도 낮춰서
                Bitmap photo = BitmapFactory.decodeFile(photoFile.getAbsolutePath());
                OutputStream os;
                try {
                    os = new FileOutputStream(photoFile);
                    photo.compress(Bitmap.CompressFormat.JPEG, 60, os);
                    os.flush();
                    os.close();
                } catch (Exception e) {
                    Log.e(getClass().getSimpleName(), "Error writing bitmap", e);
                }

                imageView.setImageBitmap(photo);
                imageView.setScaleType(ImageView.ScaleType.CENTER_INSIDE);

//                imageView.setImageBitmap( getBitmapAlbum( imageView, albumUri ) );

            } catch ( Exception e ) {
                e.printStackTrace( );
            }
            // 네트워크로 보낸다.
        }
        super.onActivityResult(requestCode, resultCode, data);
    }


    public static Bitmap rotateBitmap(Bitmap bitmap, int orientation) {

        Matrix matrix = new Matrix();
        switch (orientation) {
            case ExifInterface.ORIENTATION_NORMAL:
                return bitmap;
            case ExifInterface.ORIENTATION_FLIP_HORIZONTAL:
                matrix.setScale(-1, 1);
                break;
            case ExifInterface.ORIENTATION_ROTATE_180:
                matrix.setRotate(180);
                break;
            case ExifInterface.ORIENTATION_FLIP_VERTICAL:
                matrix.setRotate(180);
                matrix.postScale(-1, 1);
                break;
            case ExifInterface.ORIENTATION_TRANSPOSE:
                matrix.setRotate(90);
                matrix.postScale(-1, 1);
                break;
            case ExifInterface.ORIENTATION_ROTATE_90:
                matrix.setRotate(90);
                break;
            case ExifInterface.ORIENTATION_TRANSVERSE:
                matrix.setRotate(-90);
                matrix.postScale(-1, 1);
                break;
            case ExifInterface.ORIENTATION_ROTATE_270:
                matrix.setRotate(-90);
                break;
            default:
                return bitmap;
        }
        try {
            Bitmap bmRotated = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
            bitmap.recycle();
            return bmRotated;
        }
        catch (OutOfMemoryError e) {
            e.printStackTrace();
            return null;
        }
    }

    //앨범에서 선택한 사진이름 가져오기
    public String getFileName( Uri uri ) {
        Cursor cursor = getContentResolver( ).query( uri, null, null, null, null );
        try {
            if ( cursor == null ) return null;
            cursor.moveToFirst( );
            @SuppressLint("Range") String fileName = cursor.getString( cursor.getColumnIndex( OpenableColumns.DISPLAY_NAME ) );
            cursor.close( );
            return fileName;

        } catch ( Exception e ) {
            e.printStackTrace( );
            cursor.close( );
            return null;
        }
    }

    //이미지뷰에 뿌려질 앨범 비트맵 반환
    public Bitmap getBitmapAlbum( View targetView, Uri uri ) {
        try {
            ParcelFileDescriptor parcelFileDescriptor = getContentResolver( ).openFileDescriptor( uri, "r" );
            if ( parcelFileDescriptor == null ) return null;
            FileDescriptor fileDescriptor = parcelFileDescriptor.getFileDescriptor( );
            if ( fileDescriptor == null ) return null;

            int targetW = targetView.getWidth( );
            int targetH = targetView.getHeight( );

            BitmapFactory.Options options = new BitmapFactory.Options( );
            options.inJustDecodeBounds = true;

            BitmapFactory.decodeFileDescriptor( fileDescriptor, null, options );

            int photoW = options.outWidth;
            int photoH = options.outHeight;

            int scaleFactor = Math.min( photoW / targetW, photoH / targetH );
            if ( scaleFactor >= 8 ) {
                options.inSampleSize = 8;
            } else if ( scaleFactor >= 4 ) {
                options.inSampleSize = 4;
            } else {
                options.inSampleSize = 2;
            }
            options.inJustDecodeBounds = false;

            Bitmap reSizeBit = BitmapFactory.decodeFileDescriptor( fileDescriptor, null, options );

            ExifInterface exifInterface = null;
            try {
                if ( Build.VERSION.SDK_INT >= Build.VERSION_CODES.N ) {
                    exifInterface = new ExifInterface( fileDescriptor );
                }
            } catch ( IOException e ) {
                e.printStackTrace( );
            }

            int exifOrientation;
            int exifDegree = 0;

            //사진 회전값 구하기
            if ( exifInterface != null ) {
                exifOrientation = exifInterface.getAttributeInt( ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL );

                if ( exifOrientation == ExifInterface.ORIENTATION_ROTATE_90 ) {
                    exifDegree = 90;
                } else if ( exifOrientation == ExifInterface.ORIENTATION_ROTATE_180 ) {
                    exifDegree = 180;
                } else if ( exifOrientation == ExifInterface.ORIENTATION_ROTATE_270 ) {
                    exifDegree = 270;
                }
            }

            parcelFileDescriptor.close( );
            Matrix matrix = new Matrix( );
            matrix.postRotate( exifDegree );

            Bitmap reSizeExifBitmap = Bitmap.createBitmap( reSizeBit, 0, 0, reSizeBit.getWidth( ), reSizeBit.getHeight( ), matrix, true );
            return reSizeExifBitmap;

        } catch ( Exception e ) {
            e.printStackTrace( );
            return null;
        }


    }
}

[Android] 리사이클러뷰 스크롤 위치 찾기, 페이징 처리

mscha — Wed, 20 Jul 2022 18:01:55 +0900

recyclerView = findViewById(R.id.recyclerView);
recyclerView.setHasFixedSize(true);
recyclerView.setLayoutManager(new LinearLayoutManager(MainActivity.this));

// 리사이클러뷰가 맨 밑까지 갔는지 알 수 있는 방법.
recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
	@Override
	public void onScrollStateChanged(@NonNull RecyclerView recyclerView, int newState) {
		super.onScrollStateChanged(recyclerView, newState);
	}

	@Override
	public void onScrolled(@NonNull RecyclerView recyclerView, int dx, int dy) {
		super.onScrolled(recyclerView, dx, dy);
				
		// 리사이클러뷰 가장 마지막 index
		int lastPosition = ((LinearLayoutManager) recyclerView.getLayoutManager())
			.findLastCompletelyVisibleItemPosition();
		// 받아온 리사이클러 뷰 카운트
		int totalCount = recyclerView.getAdapter().getItemCount();

		// 스크롤을 맨 끝까지 한 것!
		if(lastPosition == totalCount -1){
			// 이곳에 스크롤이 맨 끝에 왔을 경우
			// 행동할 코드 입력
		}
	}
});

[Android] 이미지 처리를 위한 Glide 라이브러리 사용법

mscha — Wed, 20 Jul 2022 17:55:30 +0900

네트워크를 통해 이미지를 받아서 이미지뷰에 이미지를 설정할 수 있습니다.

이는 Glide를 이용하면 편리합니다.

build.gradle에 아래 코드를 추가해줍니다.

dependencies {
    
    implementation 'com.github.bumptech.glide:glide:4.13.2'
    annotationProcessor 'com.github.bumptech.glide:compiler:4.13.2'

}

AndroidMenifest.xml

인터넷접속 권한을 추가해줍니다.

<uses-permission android:name="android.permission.INTERNET" />

코드 예제

1. 이미지 url의 끝이 jpg와 같은 이미지 확장자가 아닌 경우

//글라이드 라이브러리를 이용해서, 이미지뷰에 표시한다.
GlideUrl url = new GlideUrl(getUrl,
        new LazyHeaders.Builder().addHeader("User-Agent", "Android").build());
Glide.with(MainActivity.this).load(url).into(imageView);

2. url의 끝이 이미지 확장자인 경우

//글라이드 라이브러리를 이용해서, 이미지뷰에 표시한다.
Glide.with(MainActivity.this).load(url).into(imageView);

.overide : 이미지의 크기를 설정할 수 있다.

.placeholder : 이미지를 받아오기 전에 디폴트 이미지를 설정할 수 있다.