COMPUTER

[DSC] 위치기반 서비스와 센서 사용하기

RINAAA — Thu, 4 Jun 2020 19:56:07 +0900

이번 주는 투표를 받아 위치기반 서비스와 센서 사용하기를 주제로 세션을 진행하겠습니다. :)

위치기반 서비스는 지상의 위치 정보를 이용해서 휴대 단말 사용자에게 다양한 서비스를 제공합니다. 안드로이드 폰은 GPS와 센서가 기본으로 장착되어 있어 자신의 위치를 확인할 수 있습니다.

1. GPS로 나의 위치 확인하기

안드로이드 기반의 스마트폰 위치는 위치 관리자(LocationManager)라는 시스템 서비스가 관리합니다. 실제로 android.location 패키지에는 이 클래스를 포함하여 위치 정보를 확인하거나 확인된 위치 정보를 사용하는데 필요한 클래스들이 정의되어 있습니다.

나의 현재 위치를 확인하는 가장 기본적인 방법은 위치 관리자에게 위치 정보를 요청하는 것입니다. 그러려면 다음과 같은 단계를 거쳐야 합니다.

1. 위치 관리자 객체 참조하기

위치 관리자(LocationManager)는 시스템 서비스로 제공되므로, getSystemService() 함수를 이용해 위치 관리자 객체를 참조합니다.

2. 위치 리스너 구현하기

위치 관리자가 알려주는 현재 위치는 위치 리스너(LocationListener)를 통해 받게 되므로 새로운 리스너를 구현하여 전달 받은 위치 정보를 처리합니다.

3. 위치 정보 업데이트 요청하기

위치 관리자에게 위치 정보가 변경될 때마다 알려달라고 요청하기 위해 requestLocationUpdate() 함수를 호출합니다. 이 함수의 parameter로 2번에서 구현한 위치 리스너 객체를 전달합니다.

4. 매니페스트에 추가하기

GPS를 사용할 수 있도록 매니페스트 파일에 ACCESS_FINE_LOCATION 권한을 추가하고 위험권한을 위한 설정과 코드를 추가합니다.

실습을 통해 현재 위치를 나타내보도록 하겠습니다.

프로젝트를 새로 만들고 이름은 Week5로 하겠습니다.

1. 위치 관리자 객체 참조하기

activitiy_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 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"
    android:orientation="vertical">

    <TextView
        android:id="@+id/tv_location"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />
    
    <Button
        android:id="@+id/btn_myLocation"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="나의 위치" />
    
</LinearLayout>

activity_main.xml에서 TextView와 Button을 하나씩 만들어 줍니다. 버튼을 누르면 내 위치 확인을 시작하도록 하고 위치가 확인되면 텍스트뷰에 보여줄 것입니다.

MainActivity.java

package com.example.week5;

import androidx.appcompat.app.AppCompatActivity;

import android.content.Context;
import android.location.Location;
import android.location.LocationManager;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {

    TextView tv_location;
    Button btn_myLocation;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        tv_location = findViewById(R.id.tv_location);
        btn_myLocation = findViewById(R.id.btn_myLocation);
        btn_myLocation.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startLocationService();
            }
        });
    }
    
    public void startLocationService() {
        LocationManager manager = (LocationManager)getSystemService(Context.LOCATION_SERVICE);
        if (Build.VERSION.SDK_INT >= 23 && 
                ContextCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            return;
        }
        Location location = manager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
        if (location != null) {
            double latitude = location.getLatitude();
            double longitude = location.getLongitude();
            String message = "최근 위치 -> Latitude : " + latitude + "\nLongitude : " + longitude;
            tv_location.setText(message);
        }
    }
}

똑같이 따라 쓰셨다면 manager.getLastKnownLocation()에서 빨간줄이 떴을거예요. 이는 권한이 없기 때문인데 필요한 권한을 추가하기 위해 AndroidManifest.xml 파일에 코드를 추가해 봅시다.

AndroidManifest.xml

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

<appication> 태그 위에 추가하시면 될 것 같습니다.

2. 위치 리스너 구현하기

위치 리스너(LocationListener)는 위치 관리자에서 전달하는 위치 정보를 받기 위해 정의된 인터페이스입니다.

위리 관리자가 위치 정보를 전달할 때 호출되므로 위치 정보를 받아 처리하려면 이 리스너의 onLocationChanged() 함수를 구현해야 합니다. MainActivity 클래스 안에 LocationListener 인터페이스를 구현하는 클래스를 내부 클래스로 정의해 보겠습니다.

MainActivity.java

    ...
    class GPSListener implements LocationListener {
        @Override
        public void onLocationChanged(Location location) {
            Double latitude = location.getLatitude();
            Double longitude = location.getLongitude();
            String message = "최근 위치 -> Latitude : " + latitude + "\nLongitude : " + longitude;
            tv_location.setText(message);
        }

        @Override
        public void onStatusChanged(String provider, int status, Bundle extras) {}

        @Override
        public void onProviderEnabled(String provider) {}

        @Override
        public void onProviderDisabled(String provider) {}
    }
    ...

3. 위치 정보 업데이트 요청하기

위치 관리자는 일정한 시간 간격으로 위치 정보를 확인하거나 일정 거리 이상을 이동했을 때 위치 정보를 전달하는 기능을 제공합니다. 위치 관리자에게 현재 위치를 알려달라고 요청하기 위해서는 requestLocationUpdates() 함수를 호출해야 하는데 parameter에는 최소 시간과 최소 거리, 위치 리스너 객체가 전달되어야 합니다. 1번에서 작성한startLocationService() 함수를 수정하겠습니다.

MainActivity.java

    public void startLocationService() {
        ...
        앞에는 그대로
        ...
        
        GPSListener gpsListener = new GPSListener();
        long minTime = 10000;
        float minDistance = 0;
        
        manager.requestLocationUpdates(LocationManager.GPS_PROVIDER, minTime, minDistance, gpsListener);
        Toast.makeText(getApplicationContext(), "내 위치확인 요청함", Toast.LENGTH_SHORT).show();
    }

최소 시간은 10초, 최소 거리는 0으로 하여 10초마다 위치 정보를 전달받게 됩니다.

4. 매니페스트에 추가하기

GPS를 이용해 위치 정보를 받기 위한 권한은 ACCESS_FINE_LOCATION으로 정의되어 있으므로 앞에서 이 권한은 추가했습니다. 그런데 이 권한은 위험 권한으로 분류되어 있으므로 위험 권한을 부여하는 설정과 코드를 추가하겠습니다.

build.gradle(Module:app)

...

allprojects {
    repositories {
        maven { url 'https://jitpack.io' }
    }
}

dependencies {
	...
    implementation 'com.github.pedroSG94:AutoPermissions:1.0.3'
}

다 입력하고 상단에 Sync Now를 클릭해주세요.

MainActivity.java

public class MainActivity extends AppCompatActivity implements AutoPermissionsListener {

    ...

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        ...

        AutoPermissions.Companion.loadAllPermissions(this, 101);
    }

    ...

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

    @Override
    public void onDenied(int i, String[] strings) {
        Toast.makeText(getApplicationContext(), "permissions denied : " + strings.length, Toast.LENGTH_SHORT).show();
    }

    @Override
    public void onGranted(int i, String[] strings) {
        Toast.makeText(getApplicationContext(), "permissions granted : " + strings.length, Toast.LENGTH_SHORT).show();
    }
}

이제 앱을 실행시켜 보겠습니다.

그러면 제일 처음에 권한을 부여하라는 대화상자가 표시됩니다. 허용해봅니다.

버튼이 존재하고 이 버튼을 누르면 현재 위치의 위도와 경도가 TextView에 나타나게 됩니다. 에뮬레이터로 실행하면 기본적으로 미국위치가 뜨고, 가상 위치를 따로 설정할 수 있습니다.

에뮬레이터 옆의 ... 버튼을 누르고 Location 탭을 누릅니다. 그리고 위치를 선택해주고 SAVE POINT를 누릅니다.

여기는 PNU라고 적어두고 OK를 누릅니다.

그리고 오른쪽 하단의 SET LOCATION을 누르면 현재 위치로 설정된 것입니다.

앱에서 다시 '나의 위치' 버튼을 누르면 PNU의 위도, 경도를 알려주는 것을 확인할 수 있습니다.

2. 현재 위치의 지도 보여주기

현재 위치를 위도, 경도로 보여주면 아무도 알아볼 수 없을 것입니다. 그렇기 때문에 지도를 이용하여 위치를 나타낼 것 입니다. 지도는 어떻게 보여주는 것일까요?

안드로이드에서는 앱 화면 안에 지도를 넣을 수 있도록 맵프래그먼트(MapFragment)가 제공됩니다. 맵 프래그먼트는 새로운 방식의 구글맵 서비스 v2 기능을 사용할 수 있도록 추가된 기능으로 Google Play Service 모듈을 사용합니다. 지도를 보여주기 위해서는 다음 과정이 필요합니다.

· Google Play Services 라이브러리 사용 설정하기

구글맵 서비스 v2는 Play Services 라이브러리를 사용합니다. 따라서 구글맵을 사용하려면 이 라이브러리를 추가해야 합니다.

· XML 레이아웃에 맵프래그먼트 추가하기

앱 화면에 지도를 넣으려면 XML 레이아웃에 맵프래그먼트를 추가합니다.

· 소스 코드에서 내 위치로 지도 이동시키기

지도를 띄울 때 내 위치가 보여야 하므로 소스 코드에 지도를 내 위치에 맞추어 이동시키는 기능을 추가합니다.

· 매니페스트에 설정 추가하기

지도를 사용하려면 권한이 필요합니다. 이 외에도 필요한 설정 정보를 매니페스트에 등록해야 합니다.

· 지도 API 키

구글맵 서비스를 사용하려면 구글 콘솔에서 지도 API 키를 발급받아 앱의 매니페스트에 넣어주어야 합니다.

실습으로 넘어가 보겠습니다.

이번에는 새로운 프로젝트를 만들어서 진행하겠습니다.

Google Play Services 라이브러리 사용 설정하기

안드로이드 스튜디오 화면의 위쪽에 있는 SDK Manager 아이콘을 눌러 SDK 매니저 화면을 불러옵니다.

그런 다음 왼쪽의 메뉴에서 Appearance & Behavior -> System Settings -> Android SDK를 선택해 주세요.

오른쪽 창에서 SDK Tools 탭을 선택하여 Google Play services 모듈이 설치되어 있는지 확인해주세요.

저처럼 설치가 되어있지 않다면 모듈을 선택해서 Apply 버튼을 누르면 설치가 될 것입니다.

설치중,,,

설치가 완료되면 Finish, OK 하면 됩니다.

XML 레이아웃에 맵프래그먼트 추가하기

File의 Project Structure를 클릭해주세요.

그리고 Dependencies의 app Module에서 + 버튼을 누르고 1 Library Dependency를 클릭해주세요.

그러면 상단에 play-services-maps 를 입력하고 Search 버튼을 누르면 검색 결과가 표시됩니다. 이를 선택한 채로 OK 버튼을 누릅니다. 그러면 Google play services 라이브러리를 사용할 수 있게 된겁니다.

이제 XML 레이아웃을 만들어 보겠습니다.

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 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"
    android:orientation="vertical">


    <fragment
        android:id="@+id/map"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1"
        class="com.google.android.gms.maps.SupportMapFragment" />

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="나의 위치" />

</LinearLayout>

class 속성으로 SupportMapFragment라는 이름의 클래스가 할당되어 있습니다. 이 객체는 소스 코드에서 참조할 수 있으며 SupportMapFragment 안에 들어있는 GoogleMap 객체 위에 지도가 표시됩니다. GoogleMap 객체는 프래그먼트가 초기화된 후에 참조할 수 있는데, 레이아웃에 정의한 MapFragment 객체를 소스 코드에서 참조한 후 getMapAsync() 함수를 호출하면 GoogleMap 객체를 초기화하는데 비동기 방식으로 처리됩니다. 따라서 콜백 객체를 parameter로 전달한 후 초기화가 완료될 때 콜백 객체 안의 함수가 자동으로 호출되도록 만듭니다.

MainActivity.java

package com.example.week5_2;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.content.ContextCompat;

import android.Manifest;
import android.content.Context;
import android.content.pm.PackageManager;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Build;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import com.google.android.gms.maps.CameraUpdate;
import com.google.android.gms.maps.CameraUpdateFactory;
import com.google.android.gms.maps.GoogleMap;
import com.google.android.gms.maps.MapsInitializer;
import com.google.android.gms.maps.OnMapReadyCallback;
import com.google.android.gms.maps.SupportMapFragment;
import com.google.android.gms.maps.model.LatLng;
import com.pedro.library.AutoPermissions;
import com.pedro.library.AutoPermissionsListener;

public class MainActivity extends AppCompatActivity implements AutoPermissionsListener {

    SupportMapFragment mapFragment;
    GoogleMap map;

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

        mapFragment = (SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map);
        mapFragment.getMapAsync(new OnMapReadyCallback() {
            @Override
            public void onMapReady(GoogleMap googleMap) {
                Log.d("Map", "지도 준비됨");
                map = googleMap;
            }
        });

        try {
            MapsInitializer.initialize(this);
        } catch (Exception e) {
            e.printStackTrace();
        }

        Button button = findViewById(R.id.button);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startLocationService();
            }
        });

        AutoPermissions.Companion.loadAllPermissions(this, 101);
    }

    public void startLocationService() {
        LocationManager manager = (LocationManager)getSystemService(Context.LOCATION_SERVICE);
        if (Build.VERSION.SDK_INT >= 23 &&
                ContextCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            return;
        }
        Location location = manager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
        if (location != null) {
            double latitude = location.getLatitude();
            double longitude = location.getLongitude();
            showCurrentLocation(latitude, longitude);
        }

        GPSListener gpsListener = new GPSListener();
        long minTime = 10000;
        float minDistance = 0;

        manager.requestLocationUpdates(LocationManager.GPS_PROVIDER, minTime, minDistance, gpsListener);
        Toast.makeText(getApplicationContext(), "내 위치확인 요청함", Toast.LENGTH_SHORT).show();
    }

    class GPSListener implements LocationListener {
        @Override
        public void onLocationChanged(Location location) {
            Double latitude = location.getLatitude();
            Double longitude = location.getLongitude();
            showCurrentLocation(latitude, longitude);
        }

        @Override
        public void onStatusChanged(String provider, int status, Bundle extras) {}

        @Override
        public void onProviderEnabled(String provider) {}

        @Override
        public void onProviderDisabled(String provider) {}
    }

    private void showCurrentLocation(Double latitude, Double longitude) {
        LatLng curPoint = new LatLng(latitude, longitude);
        map.animateCamera(CameraUpdateFactory.newLatLngZoom(curPoint, 15));
    }

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

    @Override
    public void onDenied(int i, String[] strings) {
        Toast.makeText(getApplicationContext(), "permissions denied : " + strings.length, Toast.LENGTH_SHORT).show();
    }

    @Override
    public void onGranted(int i, String[] strings) {
        Toast.makeText(getApplicationContext(), "permissions granted : " + strings.length, Toast.LENGTH_SHORT).show();
    }
}

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.week5_2">
    
    <permission android:name="com.example.week5_2.permission.MAPS_RECEIVE"
        android:protectionLevel="signature" />
    <uses-permission android:name="com.example.week5_2.permission.MAPS_RECEIVE" />
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="com.google.android.providers.gsf.permission.READ_GSERVICES" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    <uses-feature android:glEsVersion="0x00020000"
        android:required="true" />

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        
        <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.maps.v2.API_KEY"
            android:value="API_KEY를 입력해주세요" />

        <meta-data
            android:name="com.google.android.gms.version"
            android:value="@integer/google_play_services_version" />
        
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

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

</manifest>

구글맵 API 키 발급받기

마지막으로 구글맵 API 키를 발급받아 매니페스트 안에 입력해 보겠습니다.

http://console.developers.google.com

Google Cloud Platform

하나의 계정으로 모든 Google 서비스를 Google Cloud Platform을 사용하려면 로그인하세요.

accounts.google.com

사이트에 접속하여 구글 계정으로 로그인 해주세요.

왼쪽의 라이브러리를 클릭해주세요.

그리고Maps SDK for Android를 사용할 수 있도록 해야합니다. 클릭해주세요.

사용을 눌러줍니다.

사용 설정이 되면 왼쪽의 사용자 인증 정보 메뉴로 들어와줍니다. 그리고 + 사용자 인증 정보 만들기 버튼을 눌러주세요. (저는 이미 한 번 만들어서 화면이 )

여기서는 API 키를 선택해줍니다.

발급된 API 키를 복사해줍니다.

AndroidManifest.xml의 API_KEY value 값으로 방금 복사한 키를 넣어주면 됩니다.

이제 앱을 실행시키면 됩니다.

위치 권한을 허용하고 나의 위치 버튼을 클릭하면

나의 위치를 지도가 나타내는 것을 확인할 수 있습니다.

3. 지도에 아이콘 추가하기

아직은 기본 지도 외에는 아무것도 표시되어 있지 않습니다. 보통 앱을 만들 때는 현재 위치를 아이콘으로 표시하거나 주변의 카페 위치를 지도 위에 표시해 줄 수 있어야 사용자가 알고 싶어 하는 정보를 보여줄 수 있습니다.

오버레이(Overlay)란?

일반적으로 지구상의 현실 공간을 지도로 표현할 때는 레이어(Layer)로 분리하고 각각의 레이어에는 유사한 속성을 가진 객체들을 넣어주게 됩니다. 구글맵에서는 이런 레이어들을 오버레이(Overlay)라고 부릅니다.

내 현재 위치 표시를 위한 오버레이 추가하기

방금 만든 프로젝트를 그대로 사용하겠습니다.

MainActivity.java

public class MainActivity extends AppCompatActivity implements AutoPermissionsListener {

    ...

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        ...
        mapFragment = (SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map);
        mapFragment.getMapAsync(new OnMapReadyCallback() {
            @Override
            public void onMapReady(GoogleMap googleMap) {
                Log.d("Map", "지도 준비됨");
                map = googleMap;
                map.setMyLocationEnabled(true);
            }
        });
		...
    }

    @Override
    protected void onResume() {
        super.onResume();
        if (map != null) {
            map.setMyLocationEnabled(true);
        }
    }

    @Override
    protected void onPause() {
        super.onPause();
        if (map != null) {
            map.setMyLocationEnabled(false);
        }
    }
	...
}

액티비티가 중지되거나 다시 시작할 떄 현재 위치를 표시하기 위해 setMyLocationEnabled(true) 함수를 호출합니다. 이 함수는 지도 초기화가 완료된 후에 호출되는 onMapReady() 함수 안에서 호출합니다.

앱을 실행하면

내 위치가 뜨는 것을 알 수 있습니다.

4. 마커를 사용해 내 위치 표시하기

아이콘을 사용해 원하는 위치를 포인트로 쉽게 표시할 수 있는 방법은 마커(Marker)를 만들어 추가하는 것입니다. 마커는 지도 위에 표시되는 아이콘이라고 생각하면 됩니다.

drawable 폴더에 원하는 아이콘(사진)을 추가해주세요.

MainActivity.java

public class MainActivity extends AppCompatActivity implements AutoPermissionsListener {
    ...
    
    MarkerOptions myLocationMarker;

    ...

    private void showCurrentLocation(Double latitude, Double longitude) {
        ...
        showLocationMarker(curPoint);
    }
    
    private void showLocationMarker(LatLng curPoint) {
        if (myLocationMarker == null) {
            myLocationMarker = new MarkerOptions();
            myLocationMarker.position(curPoint);
            myLocationMarker.title("내 위치\n");
            myLocationMarker.snippet("GPS로 확인한 위치");
            myLocationMarker.icon(BitmapDescriptorFactory.fromResource(R.drawable.mylocation));
            map.addMarker(myLocationMarker);
        } else {
            myLocationMarker.position(curPoint);
        }
    }
	...
}

앱일 실행하고 나의 위치를 확인해보면

마커가 뜨는 것을 확인할 수 있습니다,,,,, (사이즈가 너무 크네요,, 여러분들은 사이즈 작은 사진 구해오세욥,,,)

센서 이해하기

센서는 앱의 핵심이라기보다는 부가적으로 사용성으로 높이는데 큰 도움을 주는 요소입니다. 안드로이드에서는 다양한 표준 센서들을 지원합니다.

센서 이름	상수	설명
가속 센서(Accelerometer)	TYPE_ACCELEROMETER	가속도 감지, 외부의 충격량과 방향 감지(단위: m/s^2)(중력 + 선형가속)
자이로스코프 센서(Gyroscope)	TYPE_GYROSCOPE	회전 정보 감지, 다양한 축을 따른 회전각 감지
중력 센서(Gravity)	TYPE_GRAVITY	축의 방향과 중력 감지(단위 : m/x^2)
조도 센서(Light)	TYPE_LIGHT	빛의 세기 감지(단위 : lux)
선형 가속 센서(Linear Acceleration)	TYPE_LINEAR_ACCELERATION	각 축에 따른 가속도를 감지하는 3차원 벡터(단위 : m/s^2)
근접 센서(Proximity)	TYPE_PROXIMITY	근접한 물체와의 거리 감지(단위 : cm) 단말에 따라 가깝거나 먼 정도만 표시할 수도 있음
온도 센서(Temperature)	TYPE_TEMPERATURE	온도 감지
방향 센서(Orientation)	TYPE_ORIENTATION	방향각 감지(단위 : degree)

[DSC] 서비스와 수신자 이해하기

RINAAA — Thu, 28 May 2020 23:22:56 +0900

Week4

이때까지는 화면을 만들고 화면을 구성할 때 필요한 기본적인 내용들을 살펴봤었습니다.

하지만 앱은 화면을 구성하는 요소뿐만 아니라 다른 구성 요소도 많이 필요합니다.

그 중 대표적인 요소가 서비스(Service)와 수신자(Broadcast Receiver)입니다.

서비스(Service)

service는 화면에서 실행되는 것이 아니라 화면 뒤(Background)에서 실행되는 앱의 구성요소입니다.

화면이 없으므로 액티비티와 동작하는 방식이 다르고 인텐트(intent) 안에 포함된 메시지를 주고 받을 때 사용합니다.

activity를 만들면 Manifest에 등록했던 것처럼 새로 만든 service도 Manifest에 추가해주어야 합니다.

우선 service를 실행하려면 MainActivity에서 startService() 함수를 호출하면 됩니다.

service를 시작시키기 위해 startService() 함수를 호출할 때는 intent 객체를 parameter로 전달합니다.

그리고 service가 실행 중일 때 또 startService() 함수를 호출하면 service는 이미 메모리에 만들어진 상태로 유지되지만 service 시작 목적 이외로 intent를 전달하는 목적으로도 자주 사용됩니다.

실습으로 넘어가보겠습니다.

우선 app 을 마우스 우클릭하여 New -> Service -> Service를 눌러줍니다.

그러면 위와 같은 대화상자가 등장하는데 기본값으로 두고 Finish 버튼을 누르겠습니다.

그러면 MyService.java 파일이 생성됨과 동시에

AndroidManifest.xml 파일에 <service> 태그가 자동으로 추가된 것을 확인할 수 있습니다.

현재 MyService.java 파일에는 기본적으로 onBind() 함수만 있습니다.

하지만 service의 수명주기를 관리하기 위하여 onCreate(), onDestroy(), 그리고 intent 객체를 전달받기 위한 onStartCommand() 함수를 추가하겠습니다.

MyService class 안에 마우스를 우클릭하여 Generate를 눌러줍니다.

그리고 Override Methods를 눌러줍니다. (Ctrl + O하면 바로 열려요!)

Ctrl을 누른 상태로 onCreate(), onDestroy(), onStartCommand()를 눌러주시면 한꺼번에 추가할 수 있습니다. OK 하겠습니다.

그러면 자동으로 함수가 추가된 것을 확인할 수 있습니다.

이번엔 activity_main.xml 파일로 가서 입력상자와 버튼을 하나씩 만들겠습니다.

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 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"
    android:orientation="vertical"
    android:gravity="center">

    <EditText
        android:id="@+id/editText"
        android:layout_width="200dp"
        android:layout_height="wrap_content" />

    <Button
        android:id="@+id/btn_service"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="service로 보내기" />

</LinearLayout>

'service로 보내기'라는 버튼을 누르면 입력상자에 입력한 글자를 service에 전달하도록 만들 것입니다.

데이터를 service에 전달하려면 startService() 함수를 사용하며 intent 안에 부가 데이터를 추가해서 전달하면 됩니다.

MainActivity.java

package com.example.week4;

import androidx.appcompat.app.AppCompatActivity;

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

public class MainActivity extends AppCompatActivity {

    EditText editText;
    Button btn_service;

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

        editText = findViewById(R.id.editText);
        btn_service = findViewById(R.id.btn_service);
        btn_service.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String name = editText.getText().toString();
                Intent intent = new Intent(getApplicationContext(), MyService.class);
                intent.putExtra("command", "show");
                intent.putExtra("name", name);
                startService(intent);
            }
        });
    }
}

위와 같이 입력해주세요.

이 코드를 설명하자면

intent 안에 두 개의 부가 데이터를 넣었습니다.

command는 서비스 쪽으로 전달한 intent 객체의 데이터가 어떤 목적으로 사용되는지를 구별하기 위해 넣은 것입니다.

name은 입력상자에서 가져온 문자를 전달하기 위한 것입니다.

이 두 개의 부가 데이터를 담은 intent 객체를 startService() 함수에 담았습니다. 이는 MyService에서 onStartCommand() 함수로 전달될 것입니다.

MyService.java

package com.example.week4;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;

import static android.content.ContentValues.TAG;

public class MyService extends Service {
    public MyService() {
    }

    @Override
    public IBinder onBind(Intent intent) {
        // TODO: Return the communication channel to the service.
        throw new UnsupportedOperationException("Not yet implemented");
    }

    @Override
    public void onCreate() {
        super.onCreate();
        Log.d(TAG, "onCreate() 호출됨");
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d(TAG, "onStartCommand() 호출됨");

        if (intent == null) {
            return Service.START_STICKY;
        } else {
            String command = intent.getStringExtra("command");
            String name = intent.getStringExtra("name");

            Log.d(TAG, "command : " + command + ", name : " + name);

            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (Exception e) {};
                Log.d(TAG, "Waiting " + i + "seconds.");
            }
        }
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
    }
}

전달 받은 데이터를 출력하기 위해 Log.d() 함수를 이용했습니다.

실무에서는 토스트 메시지보다 로그를 더 많이 사용하니 알아두는 것이 좋습니다.

코드에서 intent가 null이면 Service.START_STICKY를 반환합니다. 이는 service가 비정상 종료되었다는 의미이므로 시스템이 자동으로 재시작합니다. 만약 자동으로 재시작하지 않도록 만들고 싶다면 다른 상수를 사용할 수 있습니다.

null이 아니라면 intent로부터 부가 데이터를 받아 출력하고 5초동안 1초에 한 번씩 로그를 출력하도록 했습니다.

service가 서버 역할을 하면서 activity와 연결될 수 있도록 만드는 것을 바인딩(Binding)이라고 합니다. 이를 위해서는 onBind() 함수를 재정의해야 하지만 여기서는 binding 기능을 사용하지 않으므로 그냥 놔두고 진행하겠습니다.

한 번 실행시켜보겠습니다.

'Rina' 라고 입력하고 'service로 보내기' 버튼을 누르면

안드로이드 스튜디오에서 다음과 같이 로그가 나타나게 됩니다.

이번엔 onStartCommand()에서 activity 쪽으로 intent를 전달하고 화면에 띄워보도록 하겠습니다.

MyService.java 중 onStartCommand 함수

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d(TAG, "onStartCommand() 호출됨");

        if (intent == null) {
            return Service.START_STICKY;
        } else {
            String command = intent.getStringExtra("command");
            String name = intent.getStringExtra("name");

            Log.d(TAG, "command : " + command + ", name : " + name);

            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (Exception e) {};
                Log.d(TAG, "Waiting " + i + "seconds.");
            }
            Intent showIntent = new Intent(getApplicationContext(), MainActivity.class);
            showIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK |
                                Intent.FLAG_ACTIVITY_SINGLE_TOP |
                                Intent.FLAG_ACTIVITY_CLEAR_TOP);
            showIntent.putExtra("command", "show");
            showIntent.putExtra("name", name + " from service.");
            startActivity(showIntent);
        }
        return super.onStartCommand(intent, flags, startId);
    }

이번엔 intent에 flag를 추가했습니다.

FLAG_ACTIVITY_NEW_TASK는 새로운 태스크(Task)를 생성합니다. 서비스는 화면이 없기 때문에 화면이 없는 서비스에서 화면이 있는 액티비티를 띄우려면 새로운 태스크를 만들어야 하기 때문입니다.

FLAG_ACTIVITY_SINGLE_TOP과 FLAG_ACTIVITY_CLEAR_TOP은 MainActivity 객체가 이미 메모리에 만들어져 있을 때 재사용하도록 합니다.

전달 받은 인텐트를 MainActivity에서 처리해봅시다.

MainActivity.java

package com.example.week4;

import androidx.appcompat.app.AppCompatActivity;

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

public class MainActivity extends AppCompatActivity {

    EditText editText;
    Button btn_service;

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

        editText = findViewById(R.id.editText);
        btn_service = findViewById(R.id.btn_service);
        btn_service.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String name = editText.getText().toString();
                Intent intent = new Intent(getApplicationContext(), MyService.class);
                intent.putExtra("command", "show");
                intent.putExtra("name", name);
                startService(intent);
            }
        });

        Intent passedIntent = getIntent();
        processIntent(passedIntent);
    }

    @Override
    protected void onNewIntent(Intent intent) {
        processIntent(intent);
        super.onNewIntent(intent);
    }

    private void processIntent(Intent intent) {
        if (intent != null) {
            String command = intent.getStringExtra("command");
            String name = intent.getStringExtra("name");
            Toast.makeText(this, "command : " + command + ", name : " + name, Toast.LENGTH_SHORT).show();
        }
    }
}

MainActivity가 메모리에 만들어져 있지 않은 상태에서 처음 만들어진다면 onCreate()에 있는 getIntent() 함수를 통해 intent 객체를 참조하고 MainActivity가 메모리에 이미 만들어진 상태라면 onNewIntent() 함수가 호출되어 getIntent()를 수행합니다.

실행시켜 보겠습니다.

버튼을 누르고 5초 기다리고 나면 토스트 메시지를 확인할 수 있습니다.

요즘 앱들은 서비스를 자주 사용하니 액티비티에서 서비스로, 혹은 서비스에서 액티비티로 데이터를 전달하는 방법을 잘 알아두어야 합니다.

수신자(Broadcast Receiver)

브로드캐스팅(Broadcasting)이란 메시지를 여러 객체에 전달하는 것을 말합니다.

예를 들어, 문자를 받았을 때 이 문자를 SMS 수신 앱에 알려줘야 한다면 브로드캐스팅으로 전달하면 됩니다.

메시지는 단말 전체에 적용될 수 있고 이를 '글로벌 이벤트(global event)'라고 합니다.

브로드캐스트 수신자에는 onReceiver() 함수를 정의해야 합니다. 이 함수는 원하는 브로드캐스트 메시지가 도착하면 자동으로 호출됩니다. 하지만 시스템의 모든 메시지를 받을 수는 없습니다.

원하는 메시지만 받기 위해서는 인텐트 필터를 사용하여 시스템에 등록하면 됩니다.

실습해보겠습니다.

app을 마우스 우클릭하여 New -> Other -> Broadcast Receiver를 선택해줍니다.

이름은 MyReceiver 그대로하고 Finish 누르겠습니다.

그러면 MyReceiver.java 파일이 생성되고 manifest에도 <receiver> 태그가 생성됩니다. 그리고 manifest에 코드를 추가하겠습니다.

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.week4">
    
    <uses-permission android:name="android.permission.RECEIVE_SMS"/>

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <receiver
            android:name=".MyReceiver"
            android:enabled="true"
            android:exported="true">
            <intent-filter>
                <action android:name="android.provider.Telephony.SMS_RECEIVED"/>
            </intent-filter>
        </receiver>

        <service
            android:name=".MyService"
            android:enabled="true"
            android:exported="true" />

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

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

</manifest>

<receiver> 태그 안에 <intent-filter> 태그를 넣으면 어떤 인텐트를 받을 것인지 지정합니다.

<intent-filter> 태그 안에 <action> 태그를 추가하고 name 속성 값으로 android.provider.Telephony.SMS_RECEIVED를 넣었는데 이는 SMS 메시지가 들어간 인텐트를 구분하기 위한 액션 정보입니다.

또한 이 앱에서 SMS를 수신하려면 RECEIVE_SMS라는 권한이 있어야 합니다.

<application> 태그 위에 RECEIVE_SMS 권한을 추가해주세요.

그런데 이 권한은 위험 권한입니다. 위험 권한인 경우는 소스 파일에서 앱 실행 후에 사용자가 권한을 부여할 수 있도록 별도의 코드가 추가되어야 합니다. 지금은 외부 라이브러리를 사용하여 간단하게 위험 권한을 추가하는 코드를 넣겠습니다.

Gradle Script의 build.gradle (Module: app)을 수정하겠습니다.

build.gradle (Module: app)

apply plugin: 'com.android.application'

android {
    compileSdkVersion 29
    buildToolsVersion "29.0.3"

    defaultConfig {
        applicationId "com.example.week4"
        minSdkVersion 16
        targetSdkVersion 29
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

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

}

allprojects {
    repositories {
        maven {url 'https://jitpack.io'}
    }
}

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

    implementation 'androidx.appcompat:appcompat:1.1.0'
    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'androidx.test.ext:junit:1.1.1'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'

    implementation 'com.github.pedroSG94:AutoPermissions:1.0.3'
}

이렇게 코드를 추가해주시고 상단에 Sync Now를 클릭해주세요.

이제 MyReceiver.java 파일의 코드를 작성해봅시다.

MyReceiver.java

package com.example.week4;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Build;
import android.os.Bundle;
import android.telephony.SmsManager;
import android.telephony.SmsMessage;
import android.util.Log;

import java.util.Date;

import static android.content.ContentValues.TAG;

public class MyReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        // TODO: This method is called when the BroadcastReceiver is receiving
        // an Intent broadcast.
        Log.i(TAG, "onReceive() 함수 호출");
        Bundle bundle = intent.getExtras(); //intent에서 Bundle 객체 가져옴
        SmsMessage[] messages = parseSmsMessage(bundle);


        if (messages != null && messages.length > 0) {
            String sender = messages[0].getOriginatingAddress();
            Log.i(TAG, "SMS sender : " + sender);

            String contents = messages[0].getDisplayMessageBody();
            Log.i(TAG, "SMS contents : " + contents);

            Date receivedDate = new Date(messages[0].getTimestampMillis());
            Log.i(TAG, "SMS received date : " + receivedDate.toString());
        }
    }
    
    private SmsMessage[] parseSmsMessage(Bundle bundle) {
        Object[] objs = (Object[]) bundle.get("pdus");
        SmsMessage[] messages = new SmsMessage[objs.length];
        
        int smsCount = objs.length;
        for (int i = 0; i < smsCount; i++) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                String format = bundle.getString("format");
                messages[i] = SmsMessage.createFromPdu((byte[])objs[i], format);
            } else {
                messages[i] = SmsMessage.createFromPdu((byte[])objs[i]);
            }
        }
        return messages;
    }
}

우선 SMS를 받으면 onReceive() 함수가 자동으로 호출됩니다. 그리고 parameter로 전달되는 Intent 객체 안에 SMS 데이터가 들어 있습니다. intent 객체 안에 Bundle 객체가 들어있는데 이 안에도 부가 데이터가 들어 있습니다.

parseSmsMessage 함수를 호출하면 SMS 메시지 객체를 만들어 주는데 createFromPdu() 함수를 이용하여 Bundle 객체를 SmsMessage 객체로 변환하면 SMS 데이터를 받아올 수 있습니다.

getOriginatingAddress() 함수는 발신자 번호를 확인할 수 있습니다.

getMessageBody()는 문자 내용을 확인할 수 있습니다.

getTimestampMillis()를 사용하면 SMS를 받은 시각도 확인할 수 있습니다.

Build.VERSION.SDK_INT는 단말의 OS 버전을 확인할 때 사용합니다.

Build.VERSION_CODES에는 안드로이드 OS 버전별로 상수가 정의되어 있습니다.

이번엔 위험 권한을 추가하는 코드를 작성하겠습니다.

MainActivity.java

public class MainActivity extends AppCompatActivity implements AutoPermissionsListener {

    ...

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

        ...

        AutoPermissions.Companion.loadAllPermissions(this, 101);
    }

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

    @Override
    public void onDenied(int i, String[] strings) {
        Toast.makeText(this, "permissions denied : " + strings.length, Toast.LENGTH_SHORT).show();
    }

    @Override
    public void onGranted(int i, String[] strings) {
        Toast.makeText(this, "permissions granted : " + strings.length, Toast.LENGTH_SHORT).show();
    }

...

}

이 코드는 위험 권한을 자동으로 부여하는 코드입니다.

앱을 실행하면 권한을 요청하는 대화상자가 표시됩니다.

여기서 허용 버튼을 누르면 권한이 승인되고 SMS 받을 준비가 된 것입니다.

SMS는 이동통신아에 연결되어 있어야 다른 단말로부터 수신할 수 있습니다. 따라서 에뮬레이터로는 실제 SMS 수신이 불가능하지만 가상으로 SMS를 전송할 수 있는 기능이 들어 있습니다.

여기서 ... 버튼을 클릭해주세요.

그리고 Phone에 들어가셔서 SMS message 내용에 Hello!라고 입력하고 SEND MESSAGE를 보내면 됩니다.

그러면 Hello!라는 메시지가 온 것을 확인할 수 있습니다.

동시에 안드로이드 스튜디오의 로그창에는 onReceive() 함수가 호출되고 SMS 메시지 정보들이 출력되는 것을 확인할 수 있습니다.

위험 권한(Dangerous Permission)

위의 실습에서 위험 권한에 대해 살짝 언급했습니다.

안드로이드의 마시멜로 버전부터 일반 권한(Normal Permission)과 위험 권한(Dangerous Permission)으로 나뉘어져 있습니다.

인터넷을 사용할 때 부여하는 INTERNET 권한은 일반 권한입니다. 앱을 설치할 때 사용자에게 권한이 부여되어야 함을 알려주고 설치할 것인지를 물어봅니다. 사용자가 설명을 보고 수락하면 앱이 설치되고 앱에는 INTERNET 권한이 부여됩니다.

하지만 위험 권한인 RECEIVE_SMS는 설치 시에 부여한 권한은 의미가 없고 실행 시에 사용자에게 권한을 부여할 지 물어봅니다. 사용자가 권한을 부여하지 않으면 해당 기능은 동작하지 않습니다. 앱을 설치해도 권한에 따라 실행할 수 있는 기능에 제약이 생기는 것입니다. 안드로이드 앱을 주로 사용하다보면 위치, 카메라, 마이크, 갤러리, SMS 등 권한을 물어보는 알림을 받은 적이 있을겁니다. 모두 위험 권한인 것을 알 수 있습니다.

[DSC] 여러 화면 간 전환하기

RINAAA — Sun, 24 May 2020 01:22:35 +0900

Inflation이란?

인플레이션(inflation)이란 xml 레이아웃의 내용이 메모리에 객체화 되는 과정입니다.

이렇게 말하면 어렵게 들릴 수 있으니까 쉽게 말하자면 자바코드에서 setContentView()가 xml 파일이랑 연결시키는 역할을 한다했잖아요. 그래서 xml 파일이랑 연결하는 이 과정이 인플레이션이라고 생각하면 돼요.

그래서 setContentView()하기전에 xml에서 findViewById를 하려고하면 오류가 납니다.

그리고 화면 전체에 보여줄 xml 레이아웃이 아니라 부분 레이아웃을 소스 파일에 로딩하여 보여줄 수 있습니다.

그 역할을 하는게 LayoutInflater라는 클래스입니다.

실습 : LayoutInflater로 부분화면 만들기

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 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"
    android:orientation="vertical">

    <Button
        android:id="@+id/btn_inflater"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="inflater" />

    <LinearLayout
        android:id="@+id/container"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="vertical" />

</LinearLayout>

그리고 res/layout 폴더를 우클릭하여

새로운 Layout Resource File을 만들어 줍니다. xml 이름은 sub로 하겠습니다.

sub.xml

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

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="부분화면" />

</LinearLayout>

sub.xml 파일이 부분화면 역할을 할 것입니다.

MainActivity.java

package com.example.week3;

import androidx.appcompat.app.AppCompatActivity;

import android.content.Context;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.Button;
import android.widget.LinearLayout;

public class MainActivity extends AppCompatActivity {

    Button btn_inflater;
    LinearLayout container;

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

        btn_inflater = findViewById(R.id.btn_inflater);
        container = findViewById(R.id.container);
        
        btn_inflater.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                LayoutInflater inflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
                inflater.inflate(R.layout.sub, container, true);
            }
        });
    }
}

LayoutInflater가 R.layout.sub.xml을 container라는 LinearLayout에 추가해주는 코드입니다.

실행시켜 보겠습니다.

버튼을 누를 때마다 부분화면이 생성되는 것을 확인할 수 있습니다.

화면 전환하기

앱에는 여러 화면으로 구성되어 있고 화면을 전환하며 실행됩니다. 화면은 액티비티로 구현합니다. 즉, 화면을 띄우거나 닫는 과정은 액티비티를 전환하는 것과 같습니다. 따라서 액티비티에 대해서 공부하는 것은 중요합니다.

액티비티를 소스코드에서 띄울 때 startActicity() 함수를 사용하면 되는데 이 함수는 단순히 액티비티를 띄워 화면에 보이도록 하는 기능입니다. 하지만 화면을 닫고 원래의 화면으로 돌아올 때 응답을 받고 처리하는 코드가 필요합니다. 그때 사용하는 함수가 startActivityForResult()입니다.

실습 : 새 액티비티를 띄우고 닫으며 데이터 주고받기

activity_main.xml

<Button
    android:id="@+id/btn_newactivity"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="newactivity" />

그리고 또 res/layout 폴더에 새로운 Layout Resource File을 생성하고 이름은 activity_new로 하겠습니다.

activity_new.xml

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

    <Button
        android:id="@+id/btn_return"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="돌아가기" />

</LinearLayout>

이번엔 app/java/com.example.패키지명에 새로운 자바 클래스를 만들어보도록 합시다.

이름은 NewActivity로 하였습니다.

NewActivity.java

package com.example.week3;

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

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

public class NewActivity extends AppCompatActivity {

    Button btn_return;

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

        btn_return = findViewById(R.id.btn_return);

        btn_return.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent();
                intent.putExtra("name", "rina"); //부가데이터
                setResult(RESULT_OK, intent); //응답 보내기
                finish(); //현재 액티비티 종료
            }
        });

    }
}

intent에 "name"이라는 키로 "rina"라는 데이터를 가진 Extra를 담아 응답을 보냅니다.

MainActivity.java

public static final int REQUEST_CODE_MENU = 101; //새 액티비티를 띄울 때 보낼 요청 코드

이 변수는 onCreate() 함수 위에 작성해주세요.

MainActivity.java

Button btn_newactivity = findViewById(R.id.btn_newactivity);
btn_newactivity.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
    	Intent intent = new Intent(getApplicationContext(), NewActivity.class);
    	startActivityForResult(intent, REQUEST_CODE_MENU);
    }
});

이 코드는 현재 액티비티에서 NewActivity 액티비티로 화면을 전환해주는 코드입니다.

onCreate() 함수 안에 작성해주세요.

MainActivity.java

@Override
protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if(requestCode == REQUEST_CODE_MENU) {
        Toast.makeText(getApplicationContext(),
                "onActivityResult 함수 호출됨. 요청 코드 : " + resultCode,
                Toast.LENGTH_SHORT).show();
        if(resultCode == RESULT_OK) {
            String name = data.getStringExtra("name");
            Toast.makeText(getApplicationContext(),
                    "응답으로 전달된 name : " + name,
                    Toast.LENGTH_SHORT).show();
        }
    }
}

NewActivity가 종료되었을 때 결과 값을 받는 코드입니다. 만약 내가 REQUEST_CODE_MENU를 전송했다면 첫 번째 Toast가 실행되고 그 응답으로 RESULT_OK라는 응답코드를 받았다면 두 번째 Toast가 실행됩니다.

이 코드는 onCreate() 함수 바깥에 작성해주세요.

마지막으로 app/manifests를 더블 클릭해주시면

AndroidManifest.xml 파일이 나타납니다.

AndroidManifest.xml

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

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

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

</manifest>

Activity를 추가할 때마다 위 처럼 <activity android:name=".NewActivity" />를 추가해주어야합니다.

실행시켜 보겠습니다.

화질이 안좋아 잘보이진 않지만 "onActivityResult 함수 호출됨. 요청 코드 : -1"과 "응답으로 전달된 name : rina"라는 토스트 메시지가 뜨는 것을 알 수 있습니다.

액티비티의 수명주기

안드로이드의 액티비티에는 수명주기가 있습니다.

• onCreate() : 액티비티 처음 만들어졌을 때 호출됨

화면에 보이는 뷰들의 일반적인 상태를 설정하는 부분

이 함수 다음에는 항상 onStart() 함수가 호출됨

• onStart() : 액티비티 화면에 보이기 바로 전에 호출됨

액티비티가 화면 상에 보이면 이 함수 다음에 onResume() 함수가 호출됨

액티비티가 화면에서 가려지게 되면 이 함수 다음에 onStop() 함수가 호출됨

• onResume() : 사용자와 상호작용하기 바로 전에 호출됨

• onRestart() : 액티비티 중지 이후 다시 시작되기 바로 전

이 함수 다음에는 항상 onStart()함수가 호출됨

• onPause() : 또 다른 액티비티 시작하려고 할 때 호출됨

저장되지 않은 데이터를 저장소에 저장하거나 애니메이션 중인 작업을 중지하는 등의 기능을 수행하는 함수임

이 함수가 리턴하기 전에는 다음 액티비티가 시작될 수 없으므로 이 작업은 매우 빨리 수행된 후 리턴되어야 함

• onStop() : 액티비티가 사용자에게 더 이상 보이지 않을 때 호출됨

액티비티가 소멸되거나 또 다른 액티비티가 화면을 가릴 때 호출됨

• onDestroy() : 액티비티가 소멸되어 없어지기 전에 호출됨

이 함수는 액티비티가 받는 마지막 호출이 됨

실습 : 디버깅 로그로 수명주기 확인하기

MainActivity.java에서 onCreate() 함수 밖을 클릭하고 Ctrl + O를 눌러줍니다.

그러면 Override 또는 Implement 함수를 찾을 수 있습니다.

여기서 onStart(), onPause(), onResume(), onRestart(), onDestroy() 함수를 찾아서 MainActivity에 추가해줍니다.

@Override
protected void onStart() {
	super.onStart();
	Log.d("tag", "onStart");
}

@Override
protected void onPause() {
	super.onPause();
	Log.d("tag", "onPause");
}

@Override
protected void onResume() {
	super.onResume();
	Log.d("tag", "onResume");
}

@Override
protected void onRestart() {
	super.onRestart();
	Log.d("tag", "onRestart");
}

@Override
protected void onDestroy() {
	super.onDestroy();
	Log.d("tag", "onDestroy");
}

이렇게 작성하고 앱을 실행시키면

log 창에 onCreate()함수가 실행된 후 바로 onStart와 onResume이 실행된 것을 확인할 수 있고

다른 액티비티가 실행됐을 땐 onPause

다시 메인액티비티로 돌아왔을 땐 onRestart, onStart, onResume

그리고 앱을 종료했을 땐 onPause, onDestroy 함수가 실행된 것을 알 수 있습니다.

Fragment

프래그먼트(Fragment)는 하나의 화면을 여러 부분으로 나눠서 보여주거나 각각의 부분 화면 단위로 바꿔서 보여주고 싶을 때 사용합니다.

그리고 BottomNavigationView는 하단탭을 만들어줄 수 있는 기능입니다. 카카오톡에도 하단탭이 사용된 것을 알 수 있습니다.

실습 : BottomNavigationView 사용하기

우선 activity_main.xml에 버튼 하나를 추가해줍니다.

activity_main.xml

<Button
    android:id="@+id/btn_fragment"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="fragment" />

그리고 app/java/com.example.week3에 FragmentActivity.java 파일을 새로 만들겠습니다.

FragmentActivity.java

package com.example.week3;

import android.os.Bundle;

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

public class FragmentActivity extends AppCompatActivity {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
    }
}

이 액티비티와 연결할 레이아웃 xml파일도 만들어주겠습니다.

우선 design 화면에서

Palette의 Containers안에 BottomNavigationView를 다운로드 받아줍니다.

OK 눌러주시면 됩니다.

그러고나서 다음과 같이 xml 파일을 작성하겠습니다.

activity_fragment.xml

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

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

    <com.google.android.material.bottomnavigation.BottomNavigationView
        android:id="@+id/bottomNavigation"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:background="#ffffff"/>

</LinearLayout>

그리고 FragmentActivity.java의 super.onCreate(savedInstanceState); 코드 밑에 다음과 같이 작성해줍니다.

FragmentActivity.java

setContentView(R.layout.activity_fragment);

FragmentActivity와 activity_fragment.xml 파일을 연결한 것입니다.

이번엔 하단탭에 들어갈 메뉴를 만들어주겠습니다.

이번엔 res 폴더를 우클릭해서

Android Resource Directory를 생성해줍니다.

여기서 Resource type을 꼭 menu로 설정해주세요!

그리고 menu 폴더를 우클릭해서 Menu Resource File을 만들어줍니다.

이름은 bottom_menu로 하겠습니다.

이번에는 drawable 폴더를 우클릭해서 Vector Asset을 눌러줍니다.

여기서 Clip Art를 더블 클릭해주면

다음과 같이 여러가지의 아이콘들을 볼 수 있습니다. 여기서 아무거나 세 개를 drawable 폴더에 추가해주세요.

총 3개를 추가해주시면 됩니다.

그리고 아이템을 하단탭 메뉴에 추가시켜주겠습니다.

bottom_menu.xml

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">
    <item
        android:id="@+id/tab1"
        android:icon="@drawable/ic_android_black_24dp"
        android:title="tab1" />
    <item
        android:id="@+id/tab2"
        android:icon="@drawable/ic_access_time_black_24dp"
        android:title="tab2" />
    <item
        android:id="@+id/tab3"
        android:icon="@drawable/ic_add_circle_outline_black_24dp"
        android:title="tab3" />

</menu>

android:icon 부분은 본인이 추가하신 아이콘의 경로를 입력해주세요.

그리고 BottomNavigationView 태그에 다음 속성을 추가해주세요.

activity_fragment.xml

app:menu="@menu/bottom_menu"

이번엔 부분화면인 Fragment를 만들어보도록 하겠습니다.

Fragment(Blank)를 생성해줍니다.

이름은 Frag1으로 만들고나면 fragment_frag1.xml 파일이 layout 폴더에 자동으로 생성됩니다.

그러면 생성된 fragment_frag1.xml 내부의 TextView 태그의 text 속성 값에 fragment1이라고 입력해줍니다.

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

    <!-- TODO: Update blank fragment layout -->
    <TextView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:text="fragment1" />

</FrameLayout>

같은 과정을 2번 더 반복하여 Frag2와 Frag3도 만들어 주세요.

그럼 이제 하단탭을 사용할 준비가 되었습니다. FragmentActivity.java로 돌아가 코드를 작성하겠습니다.

FragmentActivity.java

package com.example.week3;

import android.os.Bundle;
import android.view.MenuItem;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentManager;


import com.google.android.material.bottomnavigation.BottomNavigationView;

import java.util.ArrayList;

public class FragmentActivity extends AppCompatActivity {

    BottomNavigationView bottomNavigationView;
    Frag1 frag1;
    Frag2 frag2;
    Frag3 frag3;

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

        bottomNavigationView = findViewById(R.id.bottomNavigation);
        frag1 = new Frag1();
        frag2 = new Frag2();
        frag3 = new Frag3();

        getSupportFragmentManager().beginTransaction().replace(R.id.mainFrame, frag1).commit();

        bottomNavigationView.setOnNavigationItemSelectedListener(new BottomNavigationView.OnNavigationItemSelectedListener() {
            @Override
            public boolean onNavigationItemSelected(@NonNull MenuItem item) {
                switch (item.getItemId()) {
                    case R.id.tab1: {
                        getSupportFragmentManager().beginTransaction().replace(R.id.mainFrame, frag1).commit();
                        return true;
                    }
                    case R.id.tab2: {
                        getSupportFragmentManager().beginTransaction().replace(R.id.mainFrame, frag2).commit();
                        return true;
                    }
                    case R.id.tab3: {
                        getSupportFragmentManager().beginTransaction().replace(R.id.mainFrame, frag3).commit();
                        return true;
                    }
                }
                return false;
            }
        });
    }
}

그리고 앱을 실행시키기 위해서 AndroidManifest.xml 파일에

<activity android:name=".FragmentActivity" />

태그를 추가하는 것을 잊지 마세요.

MainActivity.java에 FragmentActivity로 전환되는 버튼 기능을 추가하고 앱을 실행시켜보도록 하겠습니다.

MainActivity.java

Button btn_fragment = findViewById(R.id.btn_fragment);
btn_fragment.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
    	Intent intent = new Intent(getApplicationContext(), FragmentActivity.class);
    	startActivity(intent);
    }
});

실행시키면

BottomNavigationView가 잘 실행되는 것을 볼 수 있습니다.

그리고 ViewPager라고 화면을 드래그해도 fragment를 전환할 수 있습니다.

여기에 바로 실습해보도록 하겠습니다.

실습 : ViewPager 사용하기

우선 activity_fragment.xml의 FrameLayout을 viewpager로 바꿔줍니다.

activity_fragment.xml

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

    <androidx.viewpager.widget.ViewPager
        android:id="@+id/mainFrame"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1" />

    <com.google.android.material.bottomnavigation.BottomNavigationView
        android:id="@+id/bottomNavigation"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        app:menu="@menu/bottom_menu"
        android:background="#ffffff"/>

</LinearLayout>

FragmentActivity.java

package com.example.week3;

import android.os.Bundle;
import android.view.MenuItem;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentStatePagerAdapter;
import androidx.viewpager.widget.ViewPager;

import com.google.android.material.bottomnavigation.BottomNavigationView;

import java.util.ArrayList;

public class FragmentActivity extends AppCompatActivity {

    BottomNavigationView bottomNavigationView;
    Frag1 frag1;
    Frag2 frag2;
    Frag3 frag3;
    ViewPager pager;

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

        bottomNavigationView = findViewById(R.id.bottomNavigation);
        frag1 = new Frag1();
        frag2 = new Frag2();
        frag3 = new Frag3();

        //getSupportFragmentManager().beginTransaction().replace(R.id.mainFrame, frag1).commit();
        pager = findViewById(R.id.mainFrame);
        pager.setOffscreenPageLimit(3);
        final MyPagerAdapter adapter = new MyPagerAdapter(getSupportFragmentManager());
        adapter.addItem(frag1);
        adapter.addItem(frag2);
        adapter.addItem(frag3);
        pager.setAdapter(adapter);

        bottomNavigationView.setOnNavigationItemSelectedListener(new BottomNavigationView.OnNavigationItemSelectedListener() {
            @Override
            public boolean onNavigationItemSelected(@NonNull MenuItem item) {
                switch (item.getItemId()) {
                    case R.id.tab1: {
                        //getSupportFragmentManager().beginTransaction().replace(R.id.mainFrame, frag1).commit();
                        pager.setCurrentItem(0);
                        return true;
                    }
                    case R.id.tab2: {
                        //getSupportFragmentManager().beginTransaction().replace(R.id.mainFrame, frag2).commit();
                        pager.setCurrentItem(1);
                        return true;
                    }
                    case R.id.tab3: {
                        //getSupportFragmentManager().beginTransaction().replace(R.id.mainFrame, frag3).commit();
                        pager.setCurrentItem(2);
                        return true;
                    }
                }
                return false;
            }
        });

        pager.addOnPageChangeListener(new ViewPager.OnPageChangeListener() {
            @Override
            public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {

            }

            @Override
            public void onPageSelected(int position) {
                bottomNavigationView.getMenu().getItem(position).setChecked(true);
            }

            @Override
            public void onPageScrollStateChanged(int state) {

            }
        });
    }
    class MyPagerAdapter extends FragmentStatePagerAdapter {
        ArrayList<Fragment> items = new ArrayList<>();
        public MyPagerAdapter(FragmentManager fm) {
            super(fm);
        }

        public void addItem(Fragment item) {
            items.add(item);
        }

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

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

FragmentActivity.java 코드는 위와 같이 수정하면 ViewPager를 사용할 수 있습니다.

[DSC] 또 다른 위젯(Widget)과 그래들(Gradle)

RINAAA — Tue, 19 May 2020 18:09:32 +0900

[Android] - [DSC] 위젯(Widget) 익히기

[DSC] 위젯(Widget) 익히기

1. 위젯(Widget) 익히기 저번 주에는 TextView와 Button만 이용해봤었는데 이번에는 EditText, ImageView, ImageButton, CheckBox, RadioButton, CalendarView도 한 번 사용해보겠습니다. 우선 안드로이드 스튜디..

rina214.tistory.com

이전 포스트에 이어 또 다른 위젯도 알아보겠습니다.

스낵바(Snackbar)

Snackbar는 Toast 메시지와 비슷합니다.

일단 스낵바를 사용하기 위해서는 activity_main.xml 에서

이 버튼을 눌러주시면 Palette가 있을 겁니다. Palette에서

AppBarLayout을 다운로드 받아야 Snackbar를 사용가능 합니다.

그리고 버튼을 추가해줍니다.

activity_main.xml

<Button
    android:id="@+id/btn_sb"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="snackbar" />

MainActivity.java

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

btn_sb.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
    	Snackbar.make(v, "스낵바입니다.", Snackbar.LENGTH_SHORT).show();
    }
});

토스트 메시지를 띄우고 싶을 때는

Toast.makeText(MainActivity.this, "토스트 메시지입니다.", Toast.LENGTH_SHORT).show();

였는데 둘의 코드가 비슷함을 알 수 있습니다.

실행시켜보겠습니다.

알림 대화상자(Dialog)

사용자로부터 확인을 받거나 선택하게 할 때 사용합니다.

activity_main.xml

<Button
    android:id="@+id/btn_dialog"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="dialog"/>

MainActivity.java

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

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

버튼을 누르면 showMessage()라는 함수가 실행되게 하겠습니다.

그리고 showMessage()함수는 onCreate() 함수 바깥에 정의해주도록 하겠습니다.

private void showMessage() {
    AlertDialog.Builder builder = new AlertDialog.Builder(this);
    builder.setTitle("안내");
    builder.setMessage("종료하시겠습니까?");
    builder.setIcon(android.R.drawable.ic_dialog_alert);

    builder.setPositiveButton("예", new DialogInterface.OnClickListener() {
        @Override
        public void onClick(DialogInterface dialog, int which) {
            String message = "예 버튼이 눌렸습니다.";
            Toast.makeText(MainActivity.this, message, Toast.LENGTH_SHORT).show();
        }
    });

    builder.setNeutralButton("취소", new DialogInterface.OnClickListener() {
        @Override
        public void onClick(DialogInterface dialog, int which) {
            String message = "취소 버튼이 눌렸습니다.";
            Toast.makeText(MainActivity.this, message, Toast.LENGTH_SHORT).show();
        }
    });

    builder.setNegativeButton("아니오", new DialogInterface.OnClickListener() {
        @Override
        public void onClick(DialogInterface dialog, int which) {
            String message = "아니오 버튼이 눌렸습니다.";
            Toast.makeText(MainActivity.this, message, Toast.LENGTH_SHORT).show();
        }
    });

     AlertDialog dialog = builder.create();
    dialog.show();
}

setTitle으로 제목, setMessage는 전달할 내용, setIcon으로 아이콘을 설정해줄 수 있습니다.

setPositiveButton, setNeutralButton, setNegativeButton 이렇게 총 3가지의 버튼이 있습니다.

코드와 같이 각각 예, 취소, 아니오 버튼이라고 생각하면 되고 그 버튼을을 눌렀을 때 실행할 내용을 onClick 함수 내에 코드를 작성해주시면 됩니다.

실행시키면 다음과 같이 나타나는 것을 확인할 수 있습니다.

프로그레스바(Progressbar)

작업의 진행 정도를 표시하거나 작업이 진행 중임을 사용자에게 알려줄 때 사용합니다.

막대 모양

작업의 진행 정도를 알려줌

activity_main.xml

<ProgressBar
    android:id="@+id/progressBar"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    style="@style/Widget.AppCompat.ProgressBar.Horizontal"
    android:max="100"/>

MainActivity.java

ProgressBar progressBar = findViewById(R.id.progressBar);
progressBar.setProgress(80);

setProgress는 정수값을 받아 프로그레스바의 값으로 설정해줍니다.

activity_main.xml에서 max를 100으로 설정했으니 80으로 setProgress를 해주면 80%만큼 진행이 되었다라는 것을 표시할 수 있는 거예요!

원 모양

- 작업이 진행 중임을 알려줌, 반복적으로 표시됨

activity_main.xml

<Button
    android:id="@+id/btn_progress"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="progress"/>

MainActivity.java

Button btn_progress = findViewById(R.id.btn_progress);
btn_progress.setOnClickListener(new View.OnClickListener() {
	@Override
	public void onClick(View v) {
		ProgressDialog progressDialog = new ProgressDialog(MainActivity.this, android.R.style.Theme_DeviceDefault_Light_Dialog);
		progressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
		progressDialog.setMessage("데이터를 확인하는 중입니다.");
		progressDialog.show();
	}
});

데이터를 받아올 때 약간의 시간이 걸릴 수 있습니다. 그럴 때 이 ProgressDialog를 이용하시면 좋습니다.

ProgressDialog를 끝낼 때는 progressDialog.dismiss()라고 쓰시면 됩니다.

실행해보면 다음과 같은 화면을 보실 수 있습니다.

시크바(SeekBar)

SeekBar는 어떤 기능인지 확인만 하고 넘어가겠습니다.

activity_main.xml

<SeekBar
    android:layout_width="match_parent"
    android:layout_height="wrap_content" />

리소스(Resource)와 매니페스트(Manifest)

안드로이드 앱은 크게 자바코드와 리소스로 구성됩니다.

자바코드는 앱의 흐름과 기능을 정의하고

리소스는 레이아웃이나 이미지처럼 사용자에게 보여주기 위해 사용하는 파일이나 데이터를 관리합니다.

매니페스트는 리소스는 아니지만 설치된 앱의 구성요소, 권한 등을 시스템에 알려줍니다.

가장 상위 폴더에 매니페스트 파일이 있습니다.

label 값을 바꾸면 앱의 이름이 바뀌고

icon, roundIcon 을 바꾸면 앱의 아이콘이 바뀝니다.

리소스를 자바 코드와 분리하는 이유는 이해하기 쉽고 유지관리가 용이하기 때문입니다.

그래들(Gradle)

안드로이드 앱을 실행하거나 플레이스토어, 앱스토어에 올릴 때는 소스 파일이나 리소스 파일을 빌드하거나 배포하는 작업이 필요합니다. 이때 사용되는 것이 그래들(Gradle)입니다.

빌드 설정은 build.gradle 파일에 넣어 관리합니다.

프로젝트 수준과 모듈 수준으로 나뉘는데

프로젝트 수준은 classpath를 추가하는 정도 말고는 수정하는 경우가 드뭅니다.

모듈 수준은 빌드에 필요한 중요한 정보들이 들어있습니다.

- applicationId : 이 앱의 id 값으로 전 세게에서 유일한 값이어야 합니다.

- compileSdkVersion : 빌드를 진행할 때 어떤 버전의 SDK를 사용할건지 선택합니다. 보통은 최신버전을 사용합니다.

- minSdkVersion : 어떤 하위 버전까지 지원할지 지정합니다. 모든 단말을 지원하면 좋겠지만 특정 버전 이하에서는 사용하지 못하는 기능이 있기 때문에 지정해줘야 합니다.

- dependencies : 외부 라이브러리를 추가할 때 사용합니다.

settings.gradle에서는 어떤 모듈을 포함할건지에 대한 정보를 포함합니다.

나머지 그래들에서는 안드로이드 스튜디오에서 자동 설정해주는 경우가 많아서 몰라도 괜찮습니다 :)

[DSC] 위젯(Widget) 익히기

RINAAA — Mon, 18 May 2020 23:56:22 +0900

1. 위젯(Widget) 익히기

저번 주에는 TextView와 Button만 이용해봤었는데 이번에는 EditText, ImageView, ImageButton, CheckBox, RadioButton, CalendarView도 한 번 사용해보겠습니다.

우선 안드로이드 스튜디오에 새 프로젝트를 만들고 activity_mai.xml의 Layout은 LinearLayout, orientation 속성은 vertical로 바꿔주세요. 그리고 안에 위젯을 많이 추가할 예정이라 ScrollView도 이용할게요.

activity_main.xml

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

EditText

EditText는 사용자로부터 값을 입력받을 때 사용합니다.

activity_main.xml

<EditText
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:hint="텍스트를 입력해주세요."
    android:inputType="text"/>

LinearLayout 안에 위와 같이 입력해주세요.

hint 속성은 아무 값도 입력하지 않았을 때 나타나는 문구입니다.

inputType 속성은 키패드의 문자 유형을 지정할 수 있게합니다.

실행을 시키면 다음과 같이 나타납니다.

만약 text 속성을 phone으로 바꾸면

키패드가 자동적으로 숫자로 나타나게 됩니다.

그리고 EditText는 보통 사용자의 입력을 받아 다른 일을 수행하기 위해 사용되기 때문에 입력값을 받아오는 코드를 알아야겠죠??

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

<EditText
    android:id="@+id/editText"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:hint="텍스트를 입력해주세요."
    android:inputType="text"/>
    
<Button
    android:id="@+id/btn_et"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="edittext" />

위와 같이 id 값들을 부여하고 MainActivity.java 파일로 가겠습니다.

버튼을 클릭하면 TextView의 text가 EditText의 text로 설정되도록 해봅시다.

MainActivity.java

package com.example.week2;

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

public class MainActivity extends AppCompatActivity {

    TextView textView;
    EditText editText;
    Button btn_editText;

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

        textView = findViewById(R.id.textView);
        editText = findViewById(R.id.editText);
        btn_editText = findViewById(R.id.btn_et);
        
        btn_editText.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                textView.setText(editText.getText().toString());
            }
        });

    }
}

TextView 형식의 textView 변수, EditText 형식의 editText 변수, Button 형식의 btn_editText를 MainActivity 클래스 내부에서 선언하고 onCreate 함수 안에서는 id 값으로 activity_main.xml 파일에 있던 뷰들을 연결해줍니다.

그리고 btn_editText를 클릭했을 때 editText의 text를 얻어와 String 형식으로 바꾼 값을 textView의 text로 지정해준 것이 위의 코드입니다.

화질이 좋지 않아 보이실지 모르겠지만 버튼을 누르면 EditText에서 입력받은 rina라는 글씨가 최상단에 나타납니다.

ImageView, ImageButton

ImageView와 ImageButton의 차이점은 버튼 기능이 있냐 없냐의 차이이기 때문에 ImageView를 설명해드리겠습니다.

activity_main.xml

<ImageView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:src="@mipmap/ic_launcher" />

위와 같이 ImageView를 추가해주세요.

뷰에 나타내고 싶은 이미지를 src 속성에 입력해주면 이미지가 나타날거에요. @mipmap/ic_launcher는 안드로이드 스튜디오에 기본적으로 깔려있고 실행시켜보면 안드로이드가 나타날거예요.

만약 내가 원하는 이미지를 넣고 싶다면 원하는 이미지를 drawable 폴더에 넣어줍니다.

이미지 이름은 영어 소문자만 가능해요!

위와 같이 drawable 폴더에 이미지 파일을 넣어주시고

<ImageView
    android:layout_width="100dp"
    android:layout_height="100dp"
    android:src="@drawable/rina"/>

ImageView의 src를 바꿔주시면

이렇게 사진이 추가되는 것을 확인할 수 있습니다.

CheckBox

CheckBox는 말 그대로 체크를 할 수 있는 버튼입니다.

<CheckBox
    android:id="@+id/cb_pnu"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="부산대학교"/>
    
<CheckBox
    android:id="@+id/cb_computer"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="정컴" />

CheckBox를 두 개 추가해보았습니다.

사용자가 어떤 것을 눌렀는지 알아야겠죠??

<Button
    android:id="@+id/btn_cb"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="checkbox" />

버튼을 추가해주시고 MainActivity.java 파일로 가보겠습니다.

MainActivity.java

CheckBox cb_pnu, cb_computer;
Button btn_cb;

cb_pnu = findViewById(R.id.cb_pnu);
cb_computer = findViewById(R.id.cb_computer);
btn_cb = findViewById(R.id.btn_cb);

위에서와 동일하게 변수를 선언해 주시고 id로 연결을 해줍니다.

btn_cb.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
    	String checkbox = "";
    	if (cb_pnu.isChecked()) {
    		checkbox += cb_pnu.getText();
    	}
    	if (cb_computer.isChecked()) {
    		checkbox += cb_computer.getText();
    	}
    	textView.setText(checkbox);
    }
});

그리고 버튼을 클릭했을 때 cb_pnu가 체크되어 있으면 "부산대학교", cb_computer가 체크되어 있으면 "정컴"을 TextView에 나타나게 한 코드입니다. 실행시켜봅시다.

클릭하는대로 TextView에 나타나는 것을 확인할 수 있습니다.

클릭이 되었는지 확인하는 isChecked() 라는 코드만 알아도 좋을 것 같아요.

RadioButton

체크박스는 여러 개를 동시에 체크 가능하지만 라디오버튼은 그룹 내에서 하나만 선택 가능합니다. 따라서 라디오버튼이 하나가 선택이되면 나머지 라디오버튼은 선택이 해제가 됩니다.

activity_main.xml

<RadioGroup
	android:id="@+id/radiogroup"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content">

    <RadioButton
        android:id="@+id/male"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="남자" />

    <RadioButton
        android:id="@+id/female"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="여자" />

</RadioGroup>

<Button
    android:id="@+id/btn_rb"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="radiobutton" />

MainActivity.java

RadioButton rb_male, rb_female;
Button btn_rb;
RadioGroup radioGroup;

rb_male = findViewById(R.id.male);
rb_female = findViewById(R.id.female);
btn_rb = findViewById(R.id.btn_rb);
radioGroup = findViewById(R.id.radiogroup);

btn_rb.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        String radiobutton = "";
        if (rb_male.isChecked()) {
            radiobutton += rb_male.getText();
        }
        else if (rb_female.isChecked()) {
            radiobutton += rb_female.getText();
        }
    textView.setText(radiobutton);
    }
});

RadioButton은 어짜피 하나 밖에 선택안되기 때문에 else if를 씁니다.

실행시키면 다음과 같습니다.

또 다른 방법으로는 switch 문으로도 작성이 가능합니다.

radioGroup.setOnCheckedChangeListener(new RadioGroup.OnCheckedChangeListener() {
    @Override
    public void onCheckedChanged(RadioGroup group, int checkedId) {
		switch (checkedId) {
			case R.id.male : {
                textView.setText(rb_male.getText());
                break;
            }
            case R.id.female : {
                textView.setText(rb_female.getText());
                break;
            }

        }
   }
});

setOnCheckedChangeListener는 값이 바뀔 때마다 함수가 실행되기 때문에 라디오버튼을 누를 때마다 TextView의 text가 바뀝니다.

CalendarView

CalendarView는 달력을 보여주는 위젯입니다.

activity_main.xml

<CalendarView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content" />

위젯을 추가하고 실행결과만 확인해보겠습니다.

기본적으로 오늘 날짜가 잡혀있는 것을 확인할 수 있습니다.

Drawable

드로어블은 상태에 따라 그래픽이나 이미지가 선택적으로 보이게 해줍니다. 예를 들어 버튼이 눌려진 상태를 보여주고 싶을 때 사용하는 것입니다.

상태 드로어블(StateListDrawable)

뷰의 상태에 따라 뷰에 보여줄 그래픽을 다르게 지정 가능합니다.

drawable 폴더를 마우스 우클릭하여 New -> Drawable Resource File을 클릭해줍니다.

이름은 state_drawable이라고 하고 OK를 눌러주겠습니다.

그러면 이런 화면이 뜰텐데

우측 상단의 이 버튼을 클릭하면 코드를 작성할 수 있는 창이 뜹니다.

state_drawable.xml

<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:state_pressed="true"
        android:drawable="@drawable/ic_launcher_background" />
    <item android:drawable="@drawable/ic_launcher_foreground" />
</selector>

그리고 이와 같이 코드를 입력해줍니다.

selector 내부의 item이 두 가지가 있습니다.

하나는 state_pressed="true", 즉 눌려진 상태일 때, @drawable/ic_launcher_background을 보여주고

다른 하나는 눌려지지 않았을 때 겠죠? 그 때는 @drawable/ic_launcher_foreground을 보여줍니다.

그리고 activity_main.xml 파일로 돌아가 버튼을 추가해주겠습니다.

activity_main.xml

<Button
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:background="@drawable/state_drawable" />

background 속성에 방금 생성했던 state_drawable.xml 파일로 설정해주시면 완료입니다.

실행해보겠습니다.

셰이프 드로어블(ShapeDrawable)

XML로 도형을 그릴 수 있습니다.

shape_drawable이라는 이름으로 xml 파일을 만들어줍니다.

shape_drawable.xml

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="rectangle">
    <size android:width="200dp" android:height="120dp"/>
    <stroke android:width="1dp" android:color="#FF0000"/>
    <solid android:color="#FAD844"/>
    <padding android:bottom="5dp"/>
</shape>

이라고 입력해주면

이러한 도형이 만들어진 것을 확인할 수 있습니다.

코드의 의미는

activity_main.xml로 돌아가서 밑과 같이 입력해주세요.

<ImageView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:src="@drawable/shape_drawable" />

그리고 실행시켜보면

방금 만든 도형이 나타나는 것을 확인할 수 있습니다.

drawable은 이미지나 그래픽을 사용해서 좀 더 다양한 효과를 줄 수 있어 실제 앱을 만들 때 자주 사용합니다.

다음 포스트에서 이어서 진행하겠습니다. :D

[Android] - [DSC] 또 다른 위젯(Widget)과 그래들(Gradle)

[DSC] 또 다른 위젯(Widget)과 그래들(Gradle)

[Android] - [DSC] 위젯(Widget) 익히기 [DSC] 위젯(Widget) 익히기 1. 위젯(Widget) 익히기 저번 주에는 TextView와 Button만 이용해봤었는데 이번에는 EditText, ImageView, ImageButton, CheckBox, RadioButton..

rina214.tistory.com

[DSC] 안드로이드 스튜디오와 친해지기 2

RINAAA — Tue, 12 May 2020 03:32:15 +0900

DSC 2기 App Session 1주차_2

[Android] - [DSC] 안드로이드 스튜디오와 친해지기

[DSC] 안드로이드 스튜디오와 친해지기

DSC 2기 App Session 1주차 1. 안드로이드 스튜디오 설치하기 안드로이드 스튜디오를 시작하기 위해 다음 포스트를 참고해주세요! [Android] - 안드로이드 스튜디오 설치하기 안드로이드 스튜디오 설치하기 저는..

rina214.tistory.com

이전 포스트에 이어서 계속 진행하겠습니다.

6. View 익히기

뷰(View)는 일반적으로 컨트롤이나 위젯으로 불리는 UI 구성요소입니다. 사용자의 눈에 보이는 화면의 구성 요소이죠.

이 뷰를 여러 개 포함하는 것을 뷰그룹(ViewGroup)이라고 합니다. 뷰그룹 안에서는 뷰의 위치를 지정할 수 있습니다.

그리고 뷰그룹 안에 뷰그룹을 넣을 수도 있어 장점이 많이 생깁니다. 덕분에 뷰그룹은 뷰를 상속해서 뷰그룹도 뷰처럼 다룰 수 있습니다. 예를 들어 버튼은 텍스트뷰를 상속받았기 때문에 텍스트뷰의 속성을 모두 가지고 있습니다.

안드로이드는 뷰와 뷰그룹의 역할을 구분하기 위해 뷰의 종류에 따라 다른 이름으로 부르기도 합니다.

위젯(Widget) : 뷰 중에서 일반적인 컨트롤의 역할

레이아웃(Layout) : 뷰그룹 중에서 내부에 뷰들을 포함하고 있으면서 그것들을 배치하는 역할

뷰의 크기 속성

layout_width : 뷰의 가로길이이며 필수적으로 입력해야 합니다.

layout_height : 뷰의 세로 길이이며 필수적으로 입력해야 합니다.

뷰의 속성을 이해하기 위해서는 LinearLayout이 편하기 때문에 activity_main.xml 파일에서 Component Tree의 ConstraintLayout을 Convert view하여 LinearLayout으로 바꿔주겠습니다.

그리고 버튼을 하나만 남겨놓겠습니다.

제 화면과 동일하게 나타나나요?

여기서 버튼의 Attributes를 보시면

width와 height 모두 wrap_content 임을 알 수 있습니다. 이게 기본값인데 버튼의 내용물의 양만큼 크기가 커질 수 있습니다.

두 속성 모두 match_parent로 바꾸면

버튼이 폰 화면의 크기만큼 바뀐 것을 볼 수 있습니다.

크기를 숫자로도 지정할 수 있습니다.

여기서 100dp라고 입력해주시면 100dp의 크기만큼 버튼의 크기가 결정됩니다.

숫자로 크기를 정하려면 단위를 사용해서 지정해야 합니다. dp도 여러 단위 중 하나입니다. 일반적으로 단말마다 해상도나 화면의 크기가 다르기 때문에 wrap_content나 match_parent를 사용하여 전체 화면을 기준으로 뷰를 배치할 수 있습니다. 하지만 크기를 직접 지정할 때도 px가 아닌 dp나 sp 단위를 사용하면 해상도가 다른 단말에서도 뷰의 크기를 비슷하게 보이도록 만들 수 있습니다.

단위
px (픽셀) : 화면 픽셀의 수
dp 또는 dip (밀도 독립적 픽셀) : 160dpi 화면을 기준으로 한 픽셀
즉 해상도가 160dpi인 작은 화면에서는 20픽셀이던 버튼 크기를 320dpi인 약간 큰 화면에서는 40픽셀의 크기로 보이게 합니다.
sp 또는 sip (축척 독립적 픽셀) : 텍스트 크기를 지정할 때 사용하는 단위. dp와 유사하나 글꼴의 설정에 따라 1sp당 픽셀 수가 달라짐.
in (인치) : 1인치로 된 물리적 길이
mm (밀리미터) : 1밀리미터로 된 물리적 길이
ems (텍스트 크기) : 글꼴과 상관없이 동일한 텍스트 크기 표시

보통 뷰에는 dp, 글자 크기는 sp 단위를 주로 사용합니다.

뷰의 마진(margin) 속성

margin 속성은 뷰로부터 주변을 얼마나 떨어뜨릴지 지정할 수 있습니다.

위 사진은 위쪽과 왼쪽으로부터 100dp씩 margin을 준 화면입니다.

7. 레이아웃(Layout) 익히기

1) 제약 레이아웃(ConstraintLayout)

제약 레이아웃은 안드로이드 스튜디오에서 자동으로 설정해주는 기본 레이아웃입니다.

제약 레이아웃의 가장 큰 특징은 뷰의 크기와 위치를 결정할 때 제약 조건(Constraint)을 사용해 화면을 구성한다는 것입니다.

[Android] - 안드로이드 스튜디오 제약 레이아웃(ConstraintLayout)

안드로이드 스튜디오 제약 레이아웃(ConstraintLayout)

제약 레이아웃은 안드로이드 스튜디오의 기본 레이아웃입니다. 제약 레이아웃의 가장 큰 특징은 뷰의 크기와 위치를 결정할 때 제약 조건(Constraint)을 사용한다는 것입니다. 제약 조건이란 뷰가

rina214.tistory.com

2) 리니어 레이아웃(LinearLayout)

리니어 레이아웃은 뷰가 차지할 수 있는 사각형 영역을 할당한 후, 한쪽 방향으로 차례대로 뷰를 추가하면서 화면을 구성하는 레이아웃입니다. 가장 많이 사용하는 레이아웃입니다.

[Android] - 안드로이드 스튜디오 리니어 레이아웃(LinearLayout)

안드로이드 스튜디오 리니어 레이아웃(LinearLayout)

리니어 레이아웃은 뷰가 차지할 수 있는 사각형 영역을 할당한 후, 한 쪽 방향으로 차례대로 뷰를 추가하면서 화면을 구성하는 레이아웃입니다. 보통 가장 많이 사용하는 레이아웃입니다. 1. 방�

rina214.tistory.com

3) 상대 레이아웃(RelativeLayout)

상대 레이아웃은 부모 컨테이너나 다른 뷰와의 상대적 위치로 화면을 구성합니다. 상대 레이아웃의 특성을 모두 가지고 더 많은 기능을 제공하는 제약 레이아웃이 생기면서 상대 레이아웃은 주로 권장하지는 않습니다. 하지만 단순하고 이해하기 쉽기 때문에 아직 많이 사용합니다.

4) 프레임 레이아웃(FrameLayout)

프레임 레이아웃은 가장 상위에 있는 하나의 뷰 또는 뷰그룹만 보여줍니다. 여러 개의 뷰가 존재한다면 중첩하여 쌓이게 되는데 각 뷰를 전환하여 보여주는 방식으로 자주 사용합니다.

5) 테이블 레이아웃(TableLayout)

테이블 레이아웃은 격자 모양의 배열을 사용하여 화면을 구성합니다. HTML에서 사용하는 정렬 방식과 유사하지만 많이 사용하지는 않습니다.

6) 스크롤뷰(ScrollView)

스크롤뷰는 레이아웃은 아니지만 뷰그룹의 역할을 합니다. 스크롤뷰의 내부에는 하나의 뷰 또는 뷰그룹만 넣을 수 있고 해당 뷰의 내용물이 화면보다 많아지게 되면 스크롤을 자동으로 만들어줍니다.

이렇게 만드는 경우는 없겠지만 예시를 위해 TextView를 16개를 만들어보았습니다.

스크롤뷰를 쓰지 않았다면 이렇게 보이는 게 전부였겠지만

스크롤뷰 덕분에 16까지 모두 볼 수 있게 되었습니다.

뷰의 영역 익히기

뷰에는 보이지 않는 테두리(Border)가 존재합니다. 이것을 흔히 뷰의 영역(Box)라고 하는데 테두리를 기준으로 바깥쪽과 안쪽 공간이 있습니다. 바깥쪽 공간을 마진(Margin), 안쪽 공간을 패딩(Padding)이라고 합니다.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">
    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="BUTTON"
        android:layout_margin="100dp"
        android:padding="50dp"/>
</LinearLayout>

위와 같이 xml 파일을 작성하게 되면 버튼의 바깥쪽은 100dp만큼 떨어지게 되고 버튼의 안쪽에는 50dp만큼의 공간이 생기게 됩니다.

이외의 속성들

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center">
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!"
        android:textSize="20sp"
        android:textColor="#ffffff"
        android:textStyle="bold"
        android:background="#000000" />
</LinearLayout>

android:textSize : 텍스트의 크기를 설정할 수 있습니다.

android:textColor : 텍스트의 색을 설정할 수 있습니다.

#000000 : 검은색

#FFFFFF : 흰색

그리고 왼쪽에 색상을 클릭해주시면 다른 색도 설정하실 수 있습니다.

android:textStyle : 텍스트의 스타일을 설정할 수 있습니다.

normal: 기본

bold: 굵게

italic: 기울임

android:background : 뷰의 배경을 설정할 수 있습니다. 색깔을 정할 수도 있고 사진으로도 변경 가능합니다.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:gravity="center">
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!"
        android:textSize="20sp"
        android:textColor="#FF0000"
        android:textStyle="italic"
        android:background="@mipmap/ic_launcher" />
</LinearLayout>

background의 @mipmap은 안드로이드 스튜디오의 폴더 이름입니다.

res/mipmap/ic_launcher의 사진을 갖고 온 것입니다.

안드로이드 스튜디오 리니어 레이아웃(LinearLayout)

RINAAA — Tue, 12 May 2020 03:20:06 +0900

리니어 레이아웃은 뷰가 차지할 수 있는 사각형 영역을 할당한 후, 한 쪽 방향으로 차례대로 뷰를 추가하면서 화면을 구성하는 레이아웃입니다. 보통 가장 많이 사용하는 레이아웃입니다.

1. 방향 설정하기

리니어 레이아웃에서 orientation이라는 필수 속성이 있습니다. 레이아웃 내부의 뷰가 배치될 방향을 설정하는 속성입니다.

horizontal로 하면 가로 방향으로,

vertical로 설정하면 세로 방향으로 배치됩니다.

2. 뷰 정렬하기

LinearLayout에서는 뷰의 방향을 지정하여 정렬할 수 있습니다. 무게 중심을 주는 의미인데 gravity와 layout_gravity라는 속성이 있습니다. gravity는 뷰 안의 내용물을 정렬하고, layout_gravity는 부모 컨테이너의 여유 공간에 뷰가 모두 채워지지 않아서 여유 공간이 생겼을 때 여유 공간 안에서 뷰를 정렬합니다.

gravity

LinearLayout의 gravity를 center로 줬습니다. 그러면 LinearLayout의 내용물인 두 개의 Button이 LinearLayout의 중앙으로 오게 되었습니다.

Button의 gravity를 right로 줬습니다. 이번엔 Button의 내용물인 "BUTTON"이라는 text가 오른쪽으로 정렬된 것을 확인할 수 있습니다.

layout_gravity

Button의 layout_gravity 속성을 right와 center로 주었더니 위와 같이 정렬된 것을 확인할 수 있습니다.

gravity와 layout_gravity의 차이를 아시겠나요??

center와 right 이외에도 top, bottom, left, center_vertical, center_horizontal, fill, fill_vertical, fill_horizontal, clip_vertical, clip_horizontal이 있습니다. fill은 여유 공간만큼 확대해서 채우고 clip은 남는 부분을 잘라내는 속성입니다.

3. 여유 공간 분할하기

여유 공간이 있을 때 layout_weight 속성을 통해 뷰의 공간을 분할할 수 있습니다.

LinearLayout의 방향을 horizontal로 했으면 가로방향으로 설정할 수 있습니다.

따라서 Button의 width를 0dp로 지정하고 layout_weight를 1로 주니 Button이 화면의 양쪽 크기만큼 늘어났습니다.

뷰가 하나일 때에는 weight의 의미가 없습니다. 하지만 버튼이 두개가 된다면 어떨까요

버튼의 가로 길이가 1:1만큼 분할되었습니다. 두 버튼 모두 weight 값이 1이기 때문입니다.

첫 번째 버튼의 layout_weight를 2로 주었습니다. 두 버튼의 가로길이가 화면의 2 : 1만큼 분할된 것을 확인할 수 있습니다.

안드로이드 스튜디오 제약 레이아웃(ConstraintLayout)

RINAAA — Tue, 12 May 2020 02:17:39 +0900

제약 레이아웃은 안드로이드 스튜디오의 기본 레이아웃입니다.

제약 레이아웃의 가장 큰 특징은 뷰의 크기와 위치를 결정할 때 제약 조건(Constraint)을 사용한다는 것입니다.

제약 조건이란 뷰가 레이아웃 안의 다른 요소와 어떻게 연결되는지 알려주는 것으로, 뷰의 연결점(Anchor Point)과 대상(Target)을 연결합니다.

1. 제약 조건 걸기

제약 레이아웃에서 버튼을 생성하면 다음과 같이 위, 아래, 왼쪽, 오른쪽에 동그라미로 표시된 연결점을 확인할 수 있습니다. 연결점은 핸들(Side Constraint Handle)이라고도 불리며 마우스 커서로 잡아서 조절할 수 있습니다.

위와 같이 위로 잡아당기면 부모 레이아웃이 타깃이 되어 부모 레이아웃의 위쪽 벽면과 연결이 됩니다. 연결점과 타깃이 연결되면 연결선이 만들어지고 연결점은 파랗게 표시됩니다.

버튼을 화면 가운데에 배치하려면 위, 아래, 왼쪽, 오른쪽 연결점을 모두 화면의 네 벽면에 연결하면 됩니다.

(자석 아이콘(Autoconnect)이 활성화 되어있다면 첫 요소는 기본적으로 중앙에 옵니다.)

2. 바이어스(Bias) 설정하기

Attributes의 Constraint Widget을 보시면 동그라미 안에 숫자 50이 들어있는 것을 확인할 수 있는데 이는 화면에서 얼마나 치우쳐 있는지 알 수 있는 바이어스(Bias)라는 것입니다. 바이어스를 위 사진과 같이 70만큼 오른쪽으로 바꿔주시면 70%만큼 오른쪽으로 치우치게 되는 것입니다.

3. 뷰의 크기 설정하기

뷰의 크기를 바꾸려면 뷰의 모서리(파란색 네모)를 끌어당기면 됩니다.

그러면 꺾은선에서

직선으로 바뀐 것을 확인할 수 있습니다.

layout_width와 layout_height에 따라 이 모양이 바뀌는 것입니다.

꺾은선은 wrap_content,

직선은 크기 지정,

match constraint인 0dp로 설정해 주시면 구불구불한 선이 됩니다.

3. 가이드라인(Guideline) 사용하기

가이드라인은 여러 개의 뷰를 일정한 기준 선에 정렬할 때 사용합니다.

Add Horizontal Guideline을 추가하면

가로로 점선이 생긴 것을 확인할 수 있습니다.

가이드라인을 100dp만큼 움직이고

버튼의 연결점을 가이드라인에 맞추면 화면의 위에서 100만큼 떨어진 곳에서 화면의 중앙에 버튼이 위치하게 됩니다.

그리고 버튼을 3개로 추가하고 아래쪽 제약 조건을 없애면 위 사진과 같이 화면에서 100dp 만큼 떨어진 거리에서 버튼을 정렬할 수 있습니다.

4. xml 코드 확인하기

보통은 디자이너 도구의 화면보다는 Text 탭을 눌러서 원본 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">

    <androidx.constraintlayout.widget.Guideline
        android:id="@+id/guideline"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:orientation="horizontal"
        app:layout_constraintGuide_begin="100dp" />
    
    <Button
        android:id="@+id/button1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:onClick="onButton1Clicked"
        android:text="Button"
        app:layout_constraintEnd_toStartOf="@+id/button3"
        app:layout_constraintStart_toEndOf="@+id/button2"
        app:layout_constraintTop_toTopOf="@+id/guideline" />

    <Button
        android:id="@+id/button2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Button"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="@+id/guideline" />

    <Button
        android:id="@+id/button3"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Button"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintTop_toTopOf="@+id/guideline" />

</androidx.constraintlayout.widget.ConstraintLayout>

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

가장 위쪽에 있는 코드는 XML 파일에 일반적으로 추가하는 정보입니다.

androidx.constraintlayout.widget.ConstraintLayout

이 태그는 화면 전체를 감싸고 있는 최상위 레이아웃 입니다. ConstraintLayout을 나타냅니다.

이 태그의 속성으로 xmls:로 시작하는 속성의 의미는 다음과 같습니다.

접두어	의미
xmls:android	안드로이드 기본 SDK에 포함되어 있는 속성을 사용합니다.
xmls:app	프로젝트에서 사용하는 외부 라이브러리에 포함되어 있는 속성을 사용합니다. app이라는 단어는 다른 것으로 바꿀 수 있습니다.
xmls:tools	안드로이드 스튜디오의 디자이너 도구 등에서 화면에 보여줄 때 사용합니다. 이 속성은 앱이 실행될 때는 적용되지 않고 안드로이드 스튜디오에서만 적용됩니다.

android:layout_width와 android:layout_height는 안드로이드 기본 SDK에 포함되어 있는 layout_width와 layout_height의 속성을 사용한다는 의미입니다.

android:id 속성은 뷰를 구분하는 구분자 역할을 합니다. 보통 xml 파일 안에서 뷰를 구분하거나, 이 뷰를 자바 소스 파일에서 찾을 때 사용합니다. @+id/아이디 값의 형식으로 정의합니다.

제약조건으로는 layout_constraint[소스 뷰의 연결점]_[타깃 뷰의 연결점]="[타깃 뷰의 id]"로 설정합니다.

소스 뷰의 연결점으로는 contraintTop, contraintBottom, contraintLeft, contraintRight가 있고

타깃 뷰의 연결점으로는 toTopOf, toBottomOf, toLeftOf, toRightOf가 있습니다.

가이드라인의 orientation의 속성은 필수 속성입니다. 가로 방향과 세로 방향 중 하나를 지정해야합니다.

app:layout_constraintGuide_begin 속성은 부모 레이아웃 벽면에서 얼마나 떨어뜨려서 배치할지 정할 수 있는 속성입니다. begin 대신 end와 percent로도 사용할 수 있습니다.

[DSC] 안드로이드 스튜디오와 친해지기

RINAAA — Tue, 12 May 2020 00:39:36 +0900

DSC 2기 App Session 1주차

1. 안드로이드 스튜디오 설치하기

안드로이드 스튜디오를 시작하기 위해 다음 포스트를 참고해주세요!

[Android] - 안드로이드 스튜디오 설치하기

안드로이드 스튜디오 설치하기

저는 우선 안드로이드 스튜디오를 설치하기 전에 사용자 계정 이름을 영어로 바꾸는 것을 추천드립니다. (C: 안의 사용자 (User)안에 사용자 이름이 있습니다. 확인해보시길 바랍니다.) 그래야 설치하기 쉬워요,,,..

rina214.tistory.com

2. 안드로이드란?

• 구글(Google)에서 만든 스마트폰용 운영체제(OS)

• 휴대용 단말기를 위해 만들어졌을뿐만 아니라

• 다양한 앱을 만들어 설치하면 실행될 수 있도록 구성된 앱 플랫폼(Platform)

안드로이드의 장점

• 오픈 소스

안드로이드는 오픈 소스이고 아파치 2.0 라이선스를 사용합니다.

• 자바 언어 사용

많은 학생들이 배우는 기본 언어가 자바이기에 안드로이드 앱 개발자가 많습니다.

현재 안드로이드 스튜디오에는 Java와 Kotlin 개발 언어가 있습니다. 우선은 기초를 다지기 위해 자바로 안드로이드 앱을 만들어보고 시간이 남으면 코틀린도 배워봅시다.

• 쉬운 앱 간 연동

다른 앱에서 제공하는 기능을 내가 만든 앱에서도 사용할 수 있습니다. 예를 들어, 사진 찍기 기능을 가진 앱을 만들기 위해 단말의 사진 앱을 연동하면 카메라 미리 보기 화면을 직접 만들지 않아도 됩니다.

• 다양한 기능 지원

안드로이드는 리눅스 기반이라 새로운 하드웨어의 기능을 쉽게 연동할 수 있습니다.

3. Project 시작하기

안드로이드 스튜디오를 처음 실행하면 이러한 창이 뜹니다. (이전 프로젝트가 바로 뜬다면 Close Project를 하시면 이 창이 뜹니다.) 여기서 Start a new Android Studio Project를 누르시면 새 프로젝트를 생성할 수 있습니다.

그러면 템플릿을 선택하라고 뜰 겁니다.. 이 대화 상자는 앱 안에 만들어질 첫 화면의 모양을 선택하는 거예요. Empty Activity가 화면 안에 아무것도 없는 거라 일단 Empty Activity를 선택해줄게요. Next를 눌러줍니다.

여기서는 앱의 기본 정보를 입력하는 대화 상자가 나타납니다. Name에는 Project 이름 Week1, Package name에는 기본으로 사용하겠습니다. 둘 다 마음대로 입력해도 상관은 없지만 Name은 영어 대문자로 Package name은 영어 소문자로 시작해야 합니다. 그 점만 유의해주세요.

저희는 첫 기초를 배우기 위해 Language는 Java로 하겠습니다. 그리고 Finish를 눌러줍니다.

프로젝트를 생성하는데 시간이 좀 걸릴 수도 있어요.

프로젝트를 만들면 activity_main.xml과 MainActivity.java 파일이 기본적으로 생성됩니다.

MainActivity.java

이 화면이 MainActivity.java 파일이고

이 화면이 activity_main.xml 파일입니다.

activity_main.xml

우선 activity_main.xml 파일부터 살펴보겠습니다.

activity_main.xml은 우리가 스마트폰에 보여줄 화면을 구성하는 파일입니다. 이 화면은 위젯들을 드래그 앤 드롭 형식으로 꾸밀 수 있고 오른쪽 상단의 버튼을 클릭하면 코드로도 구현할 수 있습니다.

그리고 하얀색 화면은 스마트폰 화면에 나타날 디자인 화면(Design)이고 오른쪽 청록색 화면은 화면의 구성 요소만 보여주는 청사진 화면(Blue Print)입니다.

위의 파란색 버튼

을 클릭해서 Design을 고르시면 디자인 화면만 남을 거예요..

보통은 디자인 모드로 작업하고 겹치거나 가려진 요소가 없는지 확인할 때 청사진 모드로 전환하여 사용하는 경우가 많습니다.

MainActivity.java

MainActivity.java 파일은 방금 activity_main.xml파일에서 만든 화면을 어떤 식으로 동작하게 할 것인지 정해줄 수 있는 파일입니다.

두 파일의 위치는

MainActivity.java 파일은 app/java/com.example.week1 내부에 있고

activity_main.xml 파일은 app/res/layout 내부에 있습니다.

앱 실행하기

일단 기본적으로 Hello World!가 출력되는 앱을 실행시켜봅시다.

안드로이드 폰이 없으신 분들은 에뮬레이터로 실행해주세요.

[Android] - 안드로이드 스튜디오 에뮬레이터로 실행하기

안드로이드 스튜디오 에뮬레이터로 실행하기

안드로이드 스튜디오에서 프로젝트를 만들게되면 activity_main.xml 파일과 MainActivity.java 파일이 기본적으로 생성되어있습니다. 일단 기본으로 놔두고 실행만 시켜보겠습니다. 오른쪽 상단에 초록색 재생버..

rina214.tistory.com

안드로이드 폰이 있으시다면 안드로이드 폰으로 실행시키는 게 편하실 거예요.

[Android] - 안드로이드 스튜디오 안드로이드 폰 연결하기

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

안드로이드 스튜디오에서 스마트폰(안드로이드)와 연결을 하기 위해서는 스마트폰의 USB 디버깅 모드를 실행해야 합니다. 스마트폰의 설정에 들어가줍니다. 휴대전화 정보를 누릅니다. 소프트웨어 정보에 들어가..

rina214.tistory.com

앱을 실행하려면

이 버튼을 눌러주시거나 Shift + F10을 눌러주세요.

이렇게 나온다면 나만의 앱을 만들 준비가 완료되신 겁니다!

4. MainActivity.java 이해하기

package com.example.week1;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

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

프로그래밍을 해보신 분들은 알겠지만 원래 자바 파일이었다면 main 함수가 있었을 겁니다. 하지만 여기서는 main 함수가 없고 onCreate() 함수가 있습니다. onCreate()가 main() 역할을 한다고 생각할 수 있습니다.

그 안에 super는 onCreate() 함수를 호출합니다. super는 자바에서 상속받은 클래스에서 부모 클래스를 가리킬 때 사용하는 키워드입니다. 자바 모르시는 분들도 있으니 간단히 말하자면 화면의 메시지를 보여주는 기능과는 상관이 없습니다. 그래서 그냥 넘어가셔도 됩니다.

그리고 setContentView하고 R.layout.activity_main이 있습니다. setContentView() 함수는 화면에 무엇을 보여줄 것인지를 설정해주는 역할을 하고 R.layout.activity_main은 처음에 보았던 activity_main.xml의 화면이라는 것만 알면 됩니다.

총 정리하자면 위의 코드는 activity_main.xml을 폰 화면에 보여주는 것이 전부입니다!

5. activity_main.xml 이해하기

저는

이 버튼을 누른 (오른쪽 상단에 위치해 있습니다.)

이 화면을 주로 사용하지만

지금은 우선 여기서

이 버튼을 눌러 Design을 선택한 화면인

이 화면으로 진행할게요.

Attributes를 클릭하고 (화면의 우측에 위치해있어요)

이 Hello World!를 클릭해주시면

이러한 화면을 볼 수 있습니다.

여기서 Attribute의 text의 속성을 Hi, Android로 바꿔주세요.

그리고 다시 실행시키면

Hello World! 에서 Hi, Android로 바뀐 것을 확인할 수 있습니다!

1. Button 추가하기

이번엔 버튼을 추가해 볼까요?

우선 Hi, Android라고 적혀있는 TextView를 삭제해줍니다. (Hi, Android를 클릭하고 키보드의 Delete 버튼을 누르면 삭제가 가능합니다.)

그리고 이 자석 아이콘(Turn On Autoconnect)을 눌러주시면 요소를 쉽게 배치할 수 있습니다.

좌측의 팔레트(Palette)가 보이시나요?

팔레트에서는 화면에 추가할 요소(버튼, 메시지)들을 확인할 수 있습니다. 여기서 Button를 화면으로 드래그해주세요.

모두 이렇게 되셨나요?

이 상태로 앱을 실행시키면

버튼이 만들어진 것을 확인할 수 있습니다.

Button Click Event

이번엔 버튼을 클릭했을 때 메시지를 나타나게 해 봅시다.

이 개념이 이벤트를 처리한다는 개념인데 버튼을 누르는 행위는 안드로이드에서 클릭 이벤트라고 합니다.

Attribute의 onClick 속성에 onButton1Clicked라고 입력해주세요.

그리고 MainActivity.java파일로 가겠습니다.

우선 코드 작성을 편하게 하기 위해

File -> Settings 를 클릭해줍니다.

그리고 좌측의 Editor -> General -> Auto Import 를 클릭해주세요.

Java안의

Add unambiguous imports on the fly 와

Optimize imports on the fly (for current project) 항목을

체크해주시면 import 구문이 자동으로 입력될 거예요.

위 사진과 같이 onCreate()함수 하단에

public void onButton1Clicked(View v) {
    Toast.makeText(this, "버튼을 눌렀습니다.", Toast.LENGTH_LONG).show();
}

이렇게 입력해주시고 앱을 실행시키면

버튼을 눌렀습니다. 라는 메시지가 잠깐 떴다가 사라 질 겁니다.

이것을 Toast 메시지라고 합니다.

위 코드의 의미를 해석하자면

Toast.makeText( //Toast 메시지를 만들어라

this, //현재 Context에서

"버튼을 눌렀습니다.", //Toast에 나타낼 메시지

Toast.LENGTH_LONG) //Toast 메시지가 나타나는 시간, Toast.LENGTH_SHORT하시면 더 짧게 나타났다가 사라져요

.show(); //Toast를 보여줘라

가 됩니다.

Button Click Event 2

이번엔 버튼을 2개 더 추가하고 기능을 2개 더 만들어봅시다.

버튼을 추가하고 위 사진처럼 동그라미를 당겨서 버튼의 제약 조건을 걸어줍니다.

안드로이드 스튜디오는 기본적으로 ConstraintLayout을 사용하는데 이 레이아웃은 각 요소마다 제약을 걸어줘야 하기 때문입니다.

세 버튼 다 제약을 걸어주시면 다음과 같은 화면이 될 겁니다.

두 번째 버튼의 onClick 속성에는 onButton2Clicked

세 번째 버튼의 onClick 속성에는 onButton3Clicked라고 입력해주겠습니다.

그리고 MainActivity.java에

public void onButton2Clicked(View v) {
    Intent myIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("https://www.google.com"));
    startActivity(myIntent);
}

public void onButton3Clicked(View v) {
    Intent myIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("tel:010-1234-5678"));
    startActivity(myIntent);
}

위의 코드를 입력해줍니다.

여기서 Intent란 내가 하고자 하는 행위를 의미합니다. 인텐트를 사용하면 애플리케이션 구성 요소 간에 데이터를 전달하거나 실행하려는 기능이 무엇인지 안드로이드 플랫폼에 알려줄 수 있는 것이지요.

우선 앱을 실행시켜 봅시다.

첫 번째 버튼을 클릭하면 전에 했던 것과 같이 Toast 메시지가 뜨고

두 번째 버튼을 클릭하면

구글 홈페이지가

세 번째 버튼을 클릭하면

010-1234-5678에 전화걸 수 있는 화면이 나타납니다.

따라서 코드를 분석해보자면

Intent myIntent = //Intent 변수를 생성

new Intent( //새로운 Intent를 만듦

Intent.ACTION_VIEW, //화면에 보여주는 기능을 가진 Intent

Uri.parse(" ")); //Uri를 분석

"https://www.google.com" 이면 사이트 접속

"tel:010-1234-5678" 이면 전화 걸기
startActivity(myIntent); //방금 만든 Intent를 실행

[Android] - [DSC] 안드로이드 스튜디오와 친해지기 2

[DSC] 안드로이드 스튜디오와 친해지기 2

DSC 2기 App Session 1주차_2 [Android] - [DSC] 안드로이드 스튜디오와 친해지기 [DSC] 안드로이드 스튜디오와 친해지기 DSC 2기 App Session 1주차 1. 안드로이드 스튜디오 설치하기 안드로이드 스튜디오를 시��

rina214.tistory.com

나머지는 다음 포스트에 이어집니다. :)

안드로이드 스튜디오 글자 크기 변경하기

RINAAA — Mon, 11 May 2020 23:40:25 +0900

혹시 화면에 보이는 소크 코드의 글자 크기를 바꾸고 싶으시다면

File -> Settings를 클릭해주세요

그리고 좌측의 Editor -> Font를 들어가주시면 이렇게 나타납니다.

여기서 Size를 고치면 되는데 하단의 폰트 크기를 보시면서 원하는 크기만큼 조절해주세요!