정윤욱의 클라우드 기반 인공지능 개발과 DevOps 실무

안드로이드 스튜디오 깃허브 : 안드로이드 스튜디오 깃허브 연결

정윤욱 — Sat, 13 Aug 2022 16:46:00 +0900

안드로이드에서 깃허브를 연결하여

올리고 싶은 경우가 있을 것이다.

이런경우에는 일단 깃허브에서 Token을 가져와야 한다.

깃허브에 들어간 뒤 Settings 를 클릭 해준다.

Developer settings를 눌러준다.

Personal access tokens을 눌러준다.

여기까지 하면 토큰을 만들어 둔 상태이다.

다시 안드로이드 스튜디오로 돌아와서

현재 나는 토큰을 넣어 연결한 상태인데

만약 처음이면 새로만들라거나 연결하라고 적혀져 있을 것이다.

이 화면에서 내가 아까만든 토큰을 연결하게 되면 내가 연결한 깃허브가 뜰 것이다.

돌아오면 Git라는 것이 보일 것이다.

Git => GitHub => Share Project on GitHub를 클릭 해 주면

이런 코드가 나오게 될것이고 Share를 눌러주고

토큰으로 한 깃허브에 들어가게 되면 내가 만든 안드로이드 스튜디오가 있을 것이다!!

(이름은 내가 따로 바꾼 것이다) -> 원래는 안드로이드스튜디오에서 만든 이름으로 나오게 된다.

안드로이드 스튜디오 구글 맵 구현하기 / 구글 맵 보여주기

정윤욱 — Sat, 13 Aug 2022 16:45:25 +0900

안드로이드 스튜디오 구글 맵 구현하는 코드입니다.

gradle 설정 또한 해주어야 합니다.

-------------------------------------------------Manifest-----------------------------------------------------------

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

activity 사이에 넣어주면 된다.

<uses-library android:name="com.google.android.maps" />
<uses-library
    android:name="org.apache.http.legacy"
    android:required="false" />

<meta-data
    android:name="com.google.android.geo.API_KEY"
    android:value="AIzaSyARSwWyc4Bly9Wdaqc0Ba9Pp46VXAL2Agc" />
<meta-data
    android:name="com.google.android.gms.version"
    android:value="@integer/google_play_services_version" />

첫번째 value에는 내가 가져온 구글 맵 API_Key를 입력하면 된다.

두번째 value에는 구글 맵 Version 를 입력하면 된다.

모르겠는 경우 value 값에 아래와 같이 넣고

두번째 value에 "@integer/google_play_services_version" 이라 적으면 된다.

<integer name="google_play_services_version">12451000</integer>

---------------------------------------settings.gradle---------------------------------------------

pluginManagement {
    repositories {
        gradlePluginPortal()
        google()
        mavenCentral()


    }
}
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()

    }
}


rootProject.name = "GoogleMapTest"
include ':app'

---------------------------------------bulid.gradle(Module)---------------------------------------

dependencies {
    implementation 'com.google.android.gms:play-services-maps:15.0.0'
    implementation 'com.google.android.gms:play-services-location:15.0.0'
    implementation 'com.google.android.gms:play-services-places:15.0.0'


    implementation 'androidx.appcompat:appcompat:1.4.1'
    implementation 'com.google.android.material:material:1.5.0'
    implementation 'androidx.constraintlayout:constraintlayout:2.1.3'
    implementation 'androidx.legacy:legacy-support-v4:1.0.0'
    testImplementation 'junit:junit:4.13.2'
    androidTestImplementation 'androidx.test.ext:junit:1.1.3'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'

---------------------------------------MainActivity------------------------------------------------

public class MainActivity extends AppCompatActivity implements GoogleMap.OnMyLocationButtonClickListener,
        GoogleMap.OnMyLocationClickListener,
        OnMapReadyCallback {


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


        SupportMapFragment mapFragment =
                (SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map);
        mapFragment.getMapAsync(this);



        LatLngBounds australiaBounds = new LatLngBounds(
                new LatLng(-44, 113), // SW bounds
                new LatLng(-10, 154)  // NE bounds
        );
        @SuppressLint("MissingPermission")
        @Override
        public void onMapReady(GoogleMap map) {
            map.setMyLocationEnabled(true);
            map.setOnMyLocationButtonClickListener(this);
            map.setOnMyLocationClickListener(this);
            // map.setOnMarkerClickListener(markerClickListener);
            map.moveCamera(CameraUpdateFactory.newLatLngZoom(australiaBounds.getCenter(), 17));




            // 구글맵 마커 사이즈 조절하는 코드
            BitmapDrawable bitmapdraw=(BitmapDrawable)getResources().getDrawable(R.drawable.pin3);
            Bitmap b=bitmapdraw.getBitmap();
            Bitmap smallMarker = Bitmap.createScaledBitmap(b, width, height, false);
            BitmapDrawable bitmapdraw2=(BitmapDrawable)getResources().getDrawable(R.drawable.selectpin);
            Bitmap b2=bitmapdraw2.getBitmap();
            Bitmap smallMarker2 = Bitmap.createScaledBitmap(b2, width, height, false);


            // 임의로 전동 킥보드 넣는 코드
            LatLng scooter1 = new LatLng(37.544121, 126.677024);
            map.addMarker(new MarkerOptions()
                    .position(scooter1)
                    .title("1번 전동킥보드")
                    .icon(BitmapDescriptorFactory.fromBitmap(smallMarker)));
            map.moveCamera(CameraUpdateFactory.newLatLng(scooter1));

            map.setOnMarkerClickListener(new GoogleMap.OnMarkerClickListener() {
                @Override
                public boolean onMarkerClick(Marker marker) {
                    String marker_id=marker.getId();

                    if(marker_id != null){
                        marker.setIcon(BitmapDescriptorFactory.fromBitmap(smallMarker2));
                        getTitle = marker.getTitle();
                        Toast.makeText(MainActivity.this, getTitle, Toast.LENGTH_SHORT).show();

                    }else{

                    }

                    return false;
                }

            });

        }


        @Override
        public void onMyLocationClick(@NonNull Location location) { }


        @Override
        public boolean onMyLocationButtonClick() {
            Toast.makeText(this, "내 위치보기", Toast.LENGTH_SHORT)
                    .show();

            // Return false so that we don't consume the event and the default behavior still occurs
            // (the camera animates to the user's current position).
            return false;
        }
    }
}

공식사이트

https://developers.google.com/maps/documentation/android-sdk/start?hl=ko

Android용 Maps SDK 빠른 시작 | Google Developers

지금 바로 Android 앱용 Google 지도 프로젝트를 시작해 보세요. SDK 설치부터 앱 빌드 및 실행에 이르기까지 필요한 모든 것을 찾는 방법은 다음과 같습니다.

developers.google.com

구글 API 발급하기

https://hanul0147.tistory.com/322

안드로이드 스튜디오 사진 찍으면 S3에 저장하기

정윤욱 — Sat, 13 Aug 2022 16:44:48 +0900

-------Manifest-------------

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

android:networkSecurityConfig 을 해줘야 한다.

<application
    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:networkSecurityConfig="@xml/network_security_config"

---------Xml 문서------------------- 새로만들어주기------------------------------------

<?xml version="1.0" encoding="utf-8"?>
<network-security-config>
    <base-config cleartextTrafficPermitted="true">
        <trust-anchors>
            <certificates src="system" />
        </trust-anchors>
    </base-config>
</network-security-config>

------------------------------------------------------------------------------------------------

<uses-library android:name="com.google.android.maps" />
<uses-library
    android:name="org.apache.http.legacy"
    android:required="false" />

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

-------------ImageApi----------------

interface 입니다

package com.jhn.googlemaptest.api;


import com.jhn.googlemaptest.model.ImageRes;


import java.util.Map;

import okhttp3.MultipartBody;
import okhttp3.RequestBody;
import retrofit2.Call;
import retrofit2.http.GET;
import retrofit2.http.Multipart;
import retrofit2.http.POST;
import retrofit2.http.Part;
import retrofit2.http.PartMap;

public interface ImageApi {
    // 이미지 S3에 저장하기
    @Multipart
    @POST("/dev/api/v1/posting")
    Call<ImageRes> posting(@Part MultipartBody.Part image);

    // 라벨링하는 코드
    @GET("/dev/api/v1/labling")
    Call<ImageRes> labling(@Part MultipartBody.Part image,
                           @PartMap Map<String, RequestBody> params);

}

------------------ImageRes--------------------

package com.jhn.googlemaptest.model;

import java.io.Serializable;

public class ImageRes  {

    private String result;

    public String getResult() {
        return result;
    }

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

---------------------Utils----------------------------

package com.jhn.googlemaptest.utils;

public class Utils {
    // AWS URL
    public static final String BASE_URL = "서버리스 또는 aws IAM 주소 ";
    public static final String IMAGE_URL = "S3 주소 ";

    // 저장소 정보
    public static final String PREFERENCES_NAME = "yh_Scooter_DB";
}

---------------NetworkClient--------------

import android.content.Context;

import com.jhn.googlemaptest.utils.Utils;

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(Utils.BASE_URL)
                    .client(httpClient)
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();
        }
        return retrofit;
    }
}

-------------Main Code---------------

Uri fileProvider = FileProvider.getUriForFile(ResultActivity.this,
        "com.jhn.googlemaptest.fileprovider", photoFile);

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
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.app.AlertDialog;
import android.app.ProgressDialog;
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.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.TextView;
import android.widget.Toast;

import com.jhn.googlemaptest.api.ImageApi;
import com.jhn.googlemaptest.api.NetworkClient;
import com.jhn.googlemaptest.model.ImageRes;

import org.apache.commons.io.IOUtils;

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


import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.RequestBody;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import retrofit2.Retrofit;

public class ResultActivity extends AppCompatActivity {
    TextView txt1;
    TextView txt2;
    Button button;
    Button button2;
    ImageView imgPhoto;
    public static final int REQ_REGISTER_CHECK = 101;
    public static final int REQ_LOGIN_CHECK = 102;
    public static final int REQ_PHOTO_CAPTURE = 103;
    public static final int REQ_PHOTO_SELECTION = 104;
    

    private ProgressDialog progressDialog;

    String[] permissions = {
            Manifest.permission.INTERNET,
            Manifest.permission.CAMERA,
            Manifest.permission.READ_EXTERNAL_STORAGE,
            Manifest.permission.WRITE_EXTERNAL_STORAGE,
            Manifest.permission.ACCESS_COARSE_LOCATION,
            Manifest.permission.ACCESS_FINE_LOCATION
    };
    private File photoFile;

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

        txt1 = findViewById(R.id.txt1);
        txt2 = findViewById(R.id.txt2);
        button = findViewById(R.id.button);
        button2 = findViewById(R.id.button2);
        imgPhoto = findViewById(R.id.imgPhoto);


        Intent intent = getIntent();
        long duration = intent.getExtras().getLong("duration");

        txt1.setText("이용시간 : " + (duration / 60000) + "분");
        txt2.setText("이용금액 : " + (duration / 60000) * 200 + "원");



        // 사진촬영하기 버튼
      button.setOnClickListener(new View.OnClickListener() {
          @Override
          public void onClick(View view) {
              showDialog();
          }
      });

      button2.setOnClickListener(new View.OnClickListener() {
          @Override
          public void onClick(View view) {

              Intent intent = new Intent(ResultActivity.this, LastActivity.class);
              startActivity(intent);

          }
      });

    }
    private void camera(){
        int permissionCheck = ContextCompat.checkSelfPermission(
                ResultActivity.this, Manifest.permission.CAMERA);

        if(permissionCheck != PackageManager.PERMISSION_GRANTED){
            ActivityCompat.requestPermissions(ResultActivity.this,
                    new String[]{Manifest.permission.CAMERA} ,
                    1000);
            Toast.makeText(ResultActivity.this, "카메라 권한 필요합니다.",
                    Toast.LENGTH_SHORT).show();
            return;
        } else {
            Intent i = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
            if(i.resolveActivity(ResultActivity.this.getPackageManager())  != null  ){
                // 사진의 파일명을 만들기
                String fileName = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
                photoFile = getPhotoFile(fileName);

                Uri fileProvider = FileProvider.getUriForFile(ResultActivity.this,
                        "com.jhn.googlemaptest.fileprovider", photoFile);
                i.putExtra(MediaStore.EXTRA_OUTPUT, fileProvider);

                startActivityForResult(i, 100);

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


    private void album(){

        if(checkPermission()){
            displayFileChoose();
        }else{
            requestPermission();
        }
    }

    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 boolean checkPermission(){
        int result = ContextCompat.checkSelfPermission(ResultActivity.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);
    }
    private void requestPermission() {
        if(ActivityCompat.shouldShowRequestPermissionRationale(ResultActivity.this,
                Manifest.permission.WRITE_EXTERNAL_STORAGE)){
            Toast.makeText(ResultActivity.this, "권한 수락이 필요합니다.",
                    Toast.LENGTH_SHORT).show();
        }else{

            ActivityCompat.requestPermissions(ResultActivity.this,
                    new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, 500);
        }
    }

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

        switch (requestCode) {
            case 1000: {
                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    Toast.makeText(ResultActivity.this, "권한 허가 되었음",
                            Toast.LENGTH_SHORT).show();
                } else {
                    Toast.makeText(ResultActivity.this, "아직 승인하지 않았음",
                            Toast.LENGTH_SHORT).show();
                }
                break;
            }
            case 500: {
                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    Toast.makeText(ResultActivity.this, "권한 허가 되었음",
                            Toast.LENGTH_SHORT).show();
                } else {
                    Toast.makeText(ResultActivity.this, "아직 승인하지 않았음",
                            Toast.LENGTH_SHORT).show();
                }

            }

        }
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    }



    @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, 100, os);
                os.flush();
                os.close();
            } catch (Exception e) {
                Log.e(getClass().getSimpleName(), "Error writing bitmap", e);
            }
            SendImage();

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

            //  앨범 을 Uri 로 바꾸고 S3에 저장시키는 코드
            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 );

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

            } catch ( Exception e ) {
                e.printStackTrace( );
            }
        }
        super.onActivityResult(requestCode, resultCode, data);
    }

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

    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;
        }
    }

//    private void dismissProgress() {
//        progressDialog.dismiss();
//    }
    private void showDialog() {
        AlertDialog.Builder builder = new AlertDialog.Builder(ResultActivity.this);
        builder.setTitle("선택하세요").setItems(R.array.camera_array, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialogInterface, int i) {
                if (i == 0) {
                    // 카메라로 사진찍는 함수 실행
                    camera();
                } else if (i == 1) {
                    // 앨범에서 사진 가져오는 함수 실행
                    album();
                }
            }
        }); AlertDialog alertDialog = builder.create();
        alertDialog.show();
    }

    private void SendImage() {
       // S3에 보내는 코드
        Retrofit retrofit = NetworkClient.getRetrofitClient(ResultActivity.this);
        ImageApi api = retrofit.create(ImageApi.class);

        Log.i("ImageAPi 성공 시 ", "1111");
            // MemoReq memoReq = new MemoReq(title, datetime, content);

        RequestBody fileBody = RequestBody.create(photoFile,
                MediaType.parse("image/*"));
        MultipartBody.Part part = MultipartBody.Part.createFormData(
                "image", photoFile.getName(), fileBody
        );
        Log.i("img_url", photoFile.getName());
        Call< ImageRes > call = api.posting(part);
        Log.i("MyMemoApp", "2222");
        call.enqueue(new Callback<ImageRes>() {
            @Override
            public void onResponse(Call<ImageRes> call, Response<ImageRes> response) {
                // dismissProgress();
                if (response.isSuccessful()) {
                    Toast.makeText(getApplicationContext(),"성공적으로 잘 갔습니다.",Toast.LENGTH_SHORT).show();
                } else {
                    Toast.makeText(ResultActivity.this,
                            "문제 발생",
                            Toast.LENGTH_SHORT).show();
                    return;
                }
            }

            @Override
            public void onFailure(Call<ImageRes> call, Throwable t) {
                // dismissProgress();
                Toast.makeText(ResultActivity.this,
                        "네트워크 문제 발생",
                        Toast.LENGTH_SHORT).show();
                return;

            }
        });
    }
    //앨범에서 선택한 사진이름 가져오기
    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;
        }
    }

    }

안드로이드 스튜디오 사진찍기/갤러리 불러오기

정윤욱 — Sat, 13 Aug 2022 16:44:13 +0900

사진찍기와 갤러리 불러오기에 대한 선택지를 주고 선택지에 따라

사진찍기 - > 카메라 열기

갤러리 불러오기 -> 나의 갤러리 불러오기

등을 사용할 수 있다.

package com.jhn.googlemaptest;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
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.app.Activity;
import android.app.AlertDialog;
import android.app.ProgressDialog;
import android.content.Context;
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.hardware.Camera;
import android.media.ExifInterface;
import android.media.Image;
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.TextView;
import android.widget.Toast;

import com.google.android.gms.maps.GoogleMap;

import org.apache.commons.io.IOUtils;

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

public class ResultActivity extends AppCompatActivity {
    TextView txt1;
    TextView txt2;
    Button button;
    ImageView imgPhoto;
    String imgpath;
    public static final int REQ_REGISTER_CHECK = 101;
    public static final int REQ_LOGIN_CHECK = 102;
    public static final int REQ_PHOTO_CAPTURE = 103;
    public static final int REQ_PHOTO_SELECTION = 104;

    Uri uri;
    File file;

    private ProgressDialog progressDialog;

    String[] permissions = {
            Manifest.permission.INTERNET,
            Manifest.permission.CAMERA,
            Manifest.permission.READ_EXTERNAL_STORAGE,
            Manifest.permission.WRITE_EXTERNAL_STORAGE,
            Manifest.permission.ACCESS_COARSE_LOCATION,
            Manifest.permission.ACCESS_FINE_LOCATION
    };
    private File photoFile;

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

        txt1 = findViewById(R.id.txt1);
        txt2 = findViewById(R.id.txt2);
        button = findViewById(R.id.button);
        imgPhoto = findViewById(R.id.imgPhoto);


        Intent intent = getIntent();
        long duration = intent.getExtras().getLong("duration");

        txt1.setText("이용시간 : " + (duration / 60000) + "분");
        txt2.setText("이용금액 : " + (duration / 60000) * 200 + "원");


        // 권한확인
        if (!hasPermissions(this)) ActivityCompat.requestPermissions(this, permissions, 1);

        // 사진촬영하기 버튼
      button.setOnClickListener(new View.OnClickListener() {
          @Override
          public void onClick(View view) {
              showDialog();
          }
      });

    }
    private void camera(){
        int permissionCheck = ContextCompat.checkSelfPermission(
                ResultActivity.this, Manifest.permission.CAMERA);

        if(permissionCheck != PackageManager.PERMISSION_GRANTED){
            ActivityCompat.requestPermissions(ResultActivity.this,
                    new String[]{Manifest.permission.CAMERA} ,
                    1000);
            Toast.makeText(ResultActivity.this, "카메라 권한 필요합니다.",
                    Toast.LENGTH_SHORT).show();
            return;
        } else {
            Intent i = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
            if(i.resolveActivity(ResultActivity.this.getPackageManager())  != null  ){
                // 사진의 파일명을 만들기
                String fileName = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
                photoFile = getPhotoFile(fileName);

                Uri fileProvider = FileProvider.getUriForFile(ResultActivity.this,
                        "com.jhn.googlemaptest.fileprovider", photoFile);
                i.putExtra(MediaStore.EXTRA_OUTPUT, fileProvider);

                startActivityForResult(i, 100);

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


    private void album(){

        if(checkPermission()){
            displayFileChoose();
        }else{
            requestPermission();
        }
    }

    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 boolean checkPermission(){
        int result = ContextCompat.checkSelfPermission(ResultActivity.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);
    }
    private void requestPermission() {
        if(ActivityCompat.shouldShowRequestPermissionRationale(ResultActivity.this,
                Manifest.permission.WRITE_EXTERNAL_STORAGE)){
            Toast.makeText(ResultActivity.this, "권한 수락이 필요합니다.",
                    Toast.LENGTH_SHORT).show();
        }else{

            ActivityCompat.requestPermissions(ResultActivity.this,
                    new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, 500);
        }
    }

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

        switch (requestCode) {
            case 1000: {
                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    Toast.makeText(ResultActivity.this, "권한 허가 되었음",
                            Toast.LENGTH_SHORT).show();
                } else {
                    Toast.makeText(ResultActivity.this, "아직 승인하지 않았음",
                            Toast.LENGTH_SHORT).show();
                }
                break;
            }
            case 500: {
                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    Toast.makeText(ResultActivity.this, "권한 허가 되었음",
                            Toast.LENGTH_SHORT).show();
                } else {
                    Toast.makeText(ResultActivity.this, "아직 승인하지 않았음",
                            Toast.LENGTH_SHORT).show();
                }

            }

        }
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    }

    public boolean hasPermissions(Context context) {
        if (context != null && permissions != null) {
            for (String permission : permissions) {
                if (ActivityCompat.checkSelfPermission(context, permission) != PackageManager.PERMISSION_GRANTED) {
                    return false;
                }
            }
        }
        return true;
    }

    private void getPermission(){
        ActivityCompat.requestPermissions(this, permissions, 1000);
    }

    /* 사진 찍기 메서드 */
    public void showPhotoCaptureActivity(){
        try {
            file = createFile();
            if (file.exists()){
                file.delete();
            }

            file.createNewFile();
        }catch (Exception e){
            Log.e("createFile Err: ", e.getMessage());
        }

        // SDK 버전에 따른 파일 경로 설정
        if (Build.VERSION.SDK_INT >= 24){
            uri = FileProvider.getUriForFile(this, BuildConfig.APPLICATION_ID, file);
        }else {
            uri = Uri.fromFile(file);
        }

        // 사진촬영
        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
        intent.putExtra(MediaStore.EXTRA_OUTPUT, uri);
        startActivityForResult(intent, REQ_PHOTO_CAPTURE);
        this.sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE, uri));
        Toast.makeText(this, "Intent.ACTION_MEDIA_SCANNER_SCAN_FILE, uri ->" + uri, Toast.LENGTH_LONG).show();

    } // showPhotoCaptureActivity() END

    /* 이미지 파일 생성 메서드 */
    public File createFile() throws IOException {
        String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
        String imageFileName = "JPEG_" + timeStamp + "_";
        File storageDir = getExternalFilesDir(Environment.DIRECTORY_PICTURES);
        File image = File.createTempFile(
                imageFileName,  /* prefix */
                ".jpg",         /* suffix */
                storageDir      /* directory */
        );
        imgpath = image.getAbsolutePath();
        return image;
    }

    @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);
            }

//            Intent intent = new Intent(ResultActivity.this, ResultphotoActivity.class);
//            intent.putExtra("type", "camera");
//            intent.putExtra("filePath",  photoFile.getAbsolutePath());
//            startActivity(intent);

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

            Uri albumUri = data.getData( );

//            Intent intent = new Intent(ResultActivity.this, ResultphotoActivity.class);
//            intent.putExtra("type", "album");
//            intent.putExtra("imageUri", albumUri.toString());
//            startActivity(intent);

        }

        super.onActivityResult(requestCode, resultCode, data);
    }

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

    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;
        }
    }

    private void dismissProgress() {
        progressDialog.dismiss();
    }
    private void showDialog() {
        AlertDialog.Builder builder = new AlertDialog.Builder(ResultActivity.this);
        builder.setTitle("선택하세요").setItems(R.array.camera_array, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialogInterface, int i) {
                if (i == 0) {
                    // 카메라로 사진찍는 함수 실행
                    camera();
                } else if (i == 1) {
                    // 앨범에서 사진 가져오는 함수 실행
                    album();
                }
            }
        }); AlertDialog alertDialog = builder.create();
        alertDialog.show();
    }

    }

안드로이드 스튜디오 토큰 허용

정윤욱 — Sat, 13 Aug 2022 16:43:44 +0900

로그인이나 인증 한 상태에서 이용을 할 수 있게 나누는 것은 토큰이다.

토큰을 통해 인증 및 로그인 한 상태인지 알 수 있다 .

작성자는 레트로 핏을 통해 토큰을 가져왔다!

아래는 로그인 을 하는 코드 이다.

Button btnDone = findViewById(R.id.btnDone);

btnDone.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View view) {
        // 1. 이메일과 비번을 가져온다
        String email = editEmail.getText().toString().trim();
        String password = editPasswd.getText().toString().trim();
        // 2. 이메일이 정상적인지 확인한다.
        if(email.isEmpty()){
            Toast.makeText(LoginActivity.this, "이메일이 올바르지 않습니다.",
                    Toast.LENGTH_SHORT).show();
            return;
        }
        // 3. 비밀번호 갯수가 정상적인지 확인한다.
        if(password.isEmpty() || password.length() < 4 ||
                password.length() > 12){
            Toast.makeText(LoginActivity.this, "비밀번호 길이가 맞지 않습니다.",
                    Toast.LENGTH_SHORT).show();
            return;
        }

        showProgress("로그인 중입니다...");
        // 4. 네트워크 통해서 API 호출한다.
        Retrofit retrofit = NetworkClient.getRetrofitClient(LoginActivity.this);
        UserApi api = retrofit.create(UserApi.class);

        // 바디에 데이터 담아서 보낸다.
        UserReq userReq = new UserReq(email, password);
        Call<UserRes> call = api.userLogin(userReq);
        call.enqueue(new Callback<UserRes>() {
            @Override
            public void onResponse(Call<UserRes> call, Response<UserRes> response) {
                Log.i("MyMemoApp", ""+response.code());

                dismissProgress();

                // 5. 호출 결과를 보고, 처리해줄 코드를 작성한다.
                if(response.isSuccessful()){
                    // 1. accessToken을 저장하고,
                    SharedPreferences sp = getSharedPreferences(Utils.PREFERENCES_NAME, MODE_PRIVATE);

                    String accessToken = response.body().getAccess_token();

                    SharedPreferences.Editor editor = sp.edit();
                    editor.putString("accessToken", accessToken);
                    editor.apply();

                    // 2. 메인액티비티를 띄운다.
                    Intent intent = new Intent(LoginActivity.this, MainActivity.class);
                    startActivity(intent);
                    finish();
                }else{

                }
            }
            @Override
            public void onFailure(Call<UserRes> call, Throwable t) {
                dismissProgress();
            }

        });

아래는 받아온 토큰을 사용하는 방법이다.

토큰이 있는 경우와 없는 경우 다른 xml로 보여주는 코드이다.

button.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View view) {

        SharedPreferences sp = getSharedPreferences(Utils.PREFERENCES_NAME, MODE_PRIVATE);
        accessToken = sp.getString("accessToken", "");

        if(accessToken.isEmpty()){
            // 로그인 액티비티를 띄운다.
            Intent intent = new Intent(MainActivity.this, LoginActivity.class);
            startActivity(intent);
            finish();
        }else{
            Intent intent = new Intent(MainActivity.this, SelectActivity.class);
            startActivity(intent);
            finish();
        }

    }
});

// 저장소 정보
public static final String PREFERENCES_NAME = "자신의 저장소 적기";

안드로이드 스튜디오 구글 맵 위치 권한 허용 하기

정윤욱 — Sat, 13 Aug 2022 16:43:18 +0900

java.lang.SecurityException: my location requires permission ACCESS_FINE_LOCATION or ACCESS_COARSE_LOCATION

at com.jhn.googlemaptest.MainActivity.onMapReady(MainActivity.java:93)

아래와 같은 오류가 뜨는 경우가 있을 경우가 있다.

이런 오류가 뜨는 이유는 권한에 대한 오류이다.

Android 6.0 (23- 마시멜로)

이후로 부터는 필요한 권한이 있을 경우 사용자로부터 권한을 그때 받아야 한다 .

그렇기 때문에 새로운 위치 권한 요청 코드가 필요하다 .

만일 요청 코드를 넣고 싶지 않을 경우에는

targetsdk 23 으로 바꾸면 된다.

그치만 이미 23이상으로 구현 된 코드를 sdk 23으로 바뀐다고 바로 사용되지 않을 것이다.

그렇기 때문에 권한 요청 코드를 넣어주면 된다.

targetSdk 23

내가 사용한 코드는 아래와 같다.

이 코드를 넣어 권한을 허용 시켜주면 문제 없이 앱이 사용된다.!

// 권한 허용
int permissionCheck = ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION);

if(permissionCheck == PackageManager.PERMISSION_DENIED){ //포그라운드 위치 권한 확인

    //위치 권한 요청
    ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, 0);
}


int permissionCheck2 = ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_BACKGROUND_LOCATION);

if(permissionCheck == PackageManager.PERMISSION_DENIED){ //백그라운드 위치 권한 확인
    //위치 권한 요청
    ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.ACCESS_BACKGROUND_LOCATION}, 0);
}

내가 이용한 블로그 사이트

https://velog.io/@jaeyunn_15/Android-Android-%EC%9C%84%EC%B9%98-%EA%B6%8C%ED%95%9C-%EB%B3%80%EA%B2%BD-%EC%82%AC%ED%95%AD

[Android] Android 위치 권한 변경 사항

Android 11 버전 여러 업데이트 사항 중 개인정보 보호기능에서 크게 달라졌다는 글을 보았다.곧 Android 12가 출시 되겠지만 그래도... 여러 프로젝트를 해보면서 지도에서 사용자 위치 접근에 대한

velog.io

안드로이드 공식 사이트

https://developer.android.com/training/permissions/requesting.html

안드로이드 스튜디오 카카오 맵 api 이용하여 맵 띄우기

정윤욱 — Sat, 13 Aug 2022 16:42:52 +0900

1. SDK파일 다운로드

카카오 공식문서에서 DownLoad SDK 버튼을 눌러 다운받고 압축을 푼다. 위치는 상관 없다.

카카오 공식 문서 : https://apis.map.kakao.com/android/guide/

2. 카카오 개발자 사이트 - 개발자 등록, 앱 생성

개발자 사이트 https://developers.kakao.com/ 에서 개발자등록을 하고 앱을 생성한다.

내 안드로이드 프로젝트 파일의 패키지명이 필요하다.

패키지명은 프로젝트 파일 중 AndroidManifest.xml 상단에서 확인할 수 있다.

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="이 부분이 패키지명">

** 내 프로젝트의 디버그 키 해시 값 구해서 등록하기

앱을 생성하고 안드로이드 플랫폼을 등록한다.

이 때 내 안드로이드 프로젝트의 키 해시 값이 필요하다.

/ 카카오 해시키 받아오는 코드
//    private void getAppKeyHash() {
//        try {
//            PackageInfo info = getPackageManager().getPackageInfo(getPackageName(), PackageManager.GET_SIGNATURES);
//            for (Signature signature : info.signatures) {
//                MessageDigest md;
//                md = MessageDigest.getInstance("SHA");
//                md.update(signature.toByteArray());
//                String something = new String(Base64.encode(md.digest(), 0));
//                Log.e("Hash key", something);
//            }
//        } catch (Exception e) {
//            // TODO Auto-generated catch block
//            Log.e("name not found", e.toString());
//        }
//    }

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

// getAppKeyHash();   => 해시키 불러오는 코드

참고 : https://gyubgyub.tistory.com/m/29?category=858295

Log.e("Hash key", something) 부분이 해시 키 출력 코드이다.

Log.e 이므로 로그에 빨간색으로 떠서 쉽게 찾을 수 있다.

해시 키는 외부에 노출되지 않도록 하자.

참고로 이건 (개발용)디버그 키의 해시값이므로

배포 시에는 릴리즈 키를 발급해서 릴리즈 키 해시값을 넣어줘야 한다!

※※※※

여러 사람이 함께 개발한다면

개발에 참여하는 모든 사람들의 프로젝트의 키 해시값을 구해서 모두 등록해줘야한다!!

키 해시 값을 등록하지 않은 사람은 테스트 시 카카오맵 부분이 실행되지 않는다.

이걸 모르고 지나쳐서 오류잡는다고 한참 빙빙돌았다.

다른 사람들한테 저 코드 실행해서 나오는 키 해시 값 알려달라고해서

플랫폼 등록 시 키 해시 값 란에 엔터로 구분해 모두 넣어주면 된다.

※※※※

3. 다운 받은 SDK 파일을 프로젝트에 추가

먼저 안드로이드 스튜디오에서 좌측 상단 Android 옆 화살표를 눌러 Project로 바꿔준다.

아까 다운 받은 SDK 파일의 압축을 풀고 libs 폴더로 이동하면 이런 모양새다.

맨 아래 jar파일을 app > libs 폴더에 넣어준다.(위에서 Android를 Project로 바꾸지 않았다면 libs폴더가 보이지 않는다.)

app > src > main 위치에 jniLibs라는 새 폴더를 만들고

폴더 3개를 그대로 넣어준다.

4. app단의 build 파일에 의존성implementation 추가

다시 우측 상단에서 Project로 설정했던 걸 Android로 바꿔서 보기가 편하게 만들자.

build.gradle(Module: app) 파일의 dependencies 부분에 아래 코드 두 줄을 추가해준다.

(아래 사진의 두 build.gradle 중 아래 것이다)

implementation fileTree(include: ['*.jar'], dir: 'libs')
implementation files('libs/libDaumMapAndroid.jar')

이걸 해 주어야 3번에서 추가한 파일들을 프로젝트가 인식한다.

SyncNow눌러주는 거 잊지 말기

plugins {
    id 'com.android.application'
}

android {
    compileSdk 32

    defaultConfig {
        applicationId "com.jhn.maptest"
        minSdk 22
        targetSdk 32
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}

dependencies {
    implementation fileTree(include: ['*.jar'], dir: 'libs')
    implementation files('libs/libDaumMapAndroid.jar')

    implementation 'androidx.appcompat:appcompat:1.4.1'
    implementation 'com.google.android.material:material:1.5.0'
    implementation 'androidx.constraintlayout:constraintlayout:2.1.3'
    testImplementation 'junit:junit:4.13.2'
    androidTestImplementation 'androidx.test.ext:junit:1.1.3'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
}

5. AndroidMenifest.xml 파일에 Permission과 AppKey 추가

Permission 코드 추가

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

AppKey 코드 추가

<meta-data android:name="com.kakao.sdk.AppKey" android:value="XXXXXXXXXXXXXXXXXXXXXXXXXXXX"/>

android:value 에는 개발자 사이트에서 생성한 앱의 네이티브 앱 키를 넣어준다.

앱 키는 아래 사진처럼 확인할 수 있다.

AndroidMenifest.xml

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

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


    <application
        android:usesCleartextTraffic="true"
        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.MapTest">

        <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>
        <meta-data
            android:name="com.kakao.sdk.AppKey"
            android:value="네이티브 값 넣기"/>
    </application>

</manifest>

설정이 끝났다!

이제 MapView를 띄우기 위한 코드를 넣고 실행해보자.

xml 에는 id값을 갖는 레이아웃요소를 하나 만들어주자.

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">

    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_margin="20dp"
        android:text="안드로이드 카카오맵 API 활용 : \nMapView 띄우기"
        android:textColor="#822FD5"
        android:textSize="20sp"
        android:textStyle="bold"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <androidx.constraintlayout.widget.ConstraintLayout
        android:id="@+id/map_view"
        android:layout_width="match_parent"
        android:layout_height="500dp"
        android:layout_marginTop="20dp"
        app:layout_constraintTop_toBottomOf="@+id/textView" />


</androidx.constraintlayout.widget.ConstraintLayout>

뷰 바인딩을 사용했다. 앱 해시 키 얻는 부분은 이제 필요 없으니 주석처리했다.

MainActivity.kt

package com.jhn.maptest;

import androidx.appcompat.app.AppCompatActivity;

import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.Signature;
import android.os.Bundle;
import android.util.Base64;
import android.util.Log;
import android.view.ViewGroup;

import net.daum.mf.map.api.MapView;

import java.security.MessageDigest;

public class MainActivity extends AppCompatActivity {

// 카카오 해시키 받아오는 코드
//    private void getAppKeyHash() {
//        try {
//            PackageInfo info = getPackageManager().getPackageInfo(getPackageName(), PackageManager.GET_SIGNATURES);
//            for (Signature signature : info.signatures) {
//                MessageDigest md;
//                md = MessageDigest.getInstance("SHA");
//                md.update(signature.toByteArray());
//                String something = new String(Base64.encode(md.digest(), 0));
//                Log.e("Hash key", something);
//            }
//        } catch (Exception e) {
//            // TODO Auto-generated catch block
//            Log.e("name not found", e.toString());
//        }
//    }
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

// getAppKeyHash();   => 해시키 불러오는 코드

        MapView mapView = new MapView(this);

        ViewGroup mapViewContainer = (ViewGroup) findViewById(R.id.map_view);
        mapViewContainer.addView(mapView);

    }
}

MapView를 보이는 부분은 이 두 줄만 집중하면 된다.

val mapView = MapView(this)
binding.clKakaoMapView.addView(mapView)

뷰 바인딩을 사용하지 않고 바로 id로 접근하거나 findViewById를 쓴다면

binding.부분을 제외하고 뷰 요소 접근해서 .addView(mapView)해주면 된다.

안드로이드 스튜디오 앱 시작시 로고 보여주기

정윤욱 — Sat, 13 Aug 2022 16:41:13 +0900

LogoActivity를 통해 Logo 사진을 만들어 둔 뒤 2초뒤 화면 전환을 해준다.

=======================================================

activity_logo.xml

안드로이드 스튜디오 retrofit2

정윤욱 — Sat, 13 Aug 2022 16:40:47 +0900

아래 있는 주소는 retrofit 의 공식 사이트이다.

https://square.github.io/retrofit/

Retrofit

A type-safe HTTP client for Android and Java

square.github.io

비주얼 스튜디오를 통해 데이터 베이스와

RESTfull 을 사용한 것을 안드로이드 스튜디오를 통해 애뮬레이터에 연결하려 하고 있다.

=================================================================

bulid.gradle 에서 빨간 박스들을 추가 시켜준다.

===========================================================================

api 파일 안에 NetworkClient

==================================================================

api => UserApi

============================================================================

model => UserReq (User의 정보를 요청하는 것이다.)

=====================================================================

model => UserRes (User의 정보를 받는 것이다.)

=========================================================================

Utils => Utils (BASE_URL 에는 Postman 또는 AWS RESTfull 에서 가져온 주소를 적으면 된다.)

============================================================================

MainActivtiy / activity_main.xml

============================================================================

SignUpActivity / SignUpActivity.xml

============================================================================

LoginActivity / LoginActivity.xml

안드로이드 스튜디오 유튜브 연결하기

정윤욱 — Sat, 13 Aug 2022 16:39:49 +0900

1. Youtube Data API 키 발급

https://console.developers.google.com/

Google 클라우드 플랫폼

로그인 Google 클라우드 플랫폼으로 이동

accounts.google.com

출처: https://haruple.tistory.com/161 [하루플스토리]

2.API를 다운로드 받고, 압축을 풉니다.

이후 Project - app - libs 에 붙여넣습니다.

주의해야 할 점은 extends에서 AppCompatActivity가 아닌 YouTubeBaseActivity를 꼭 extends 해야합니다.

위 소스코드대로 하면 작동 잘 될거에요!

여기까지 진행하고 본인 스마트폰을 연결하여 테스트 해보시면 됩니다!