Do it now!

Freecell solitare 카드 게임은 어떠한 개인 정보도 수집하지 않습니다.

Freecell solitare Card Game does not collect any personal information.

AndroidManifest.xml에 아래와 같이 권한을 추가 한다

    <uses-feature
        android:name="android.hardware.telephony"
        android:required="false" />

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

 MainActivity안에 아래와 같이 버튼에 이벤트를 연결한다.

    private fun init() {
        val callButton : Button = findViewById(R.id.callButton)
        callButton.setOnClickListener( View.OnClickListener { _ -> runCall() })
    }

    private fun runCall() {
        val intent = Intent(Intent.ACTION_CALL, Uri.parse("tel:01234561492"))
        val status = ActivityCompat.checkSelfPermission(this, 
            android.Manifest.permission.CALL_PHONE) == PackageManager.PERMISSION_GRANTED
        if (status) {
            startActivity(intent)
        } else {
            Log.i("TAG", "Unable to launch call");
            ActivityCompat.requestPermissions(this, 
                arrayOf<String>(android.Manifest.permission.CALL_PHONE), CALL_REQUEST)
        }
    }

아래와 같이 onRequestPermissionsReseult()를 오버라이딩 해주면, 권한 컨펌 즉시 콜이 걸리게 된다.

    override fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<out String>,
        grantResults: IntArray
    ) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        when (requestCode) {
            CALL_REQUEST -> {
                if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    Toast.makeText(this, "통화가 가능 합니다", Toast.LENGTH_LONG).show()
                    runCall()
                } else {
                    Toast.makeText(this, "통화가 거절 되었습니다", Toast.LENGTH_LONG).show()
                }
            }
        }
    }

TextView에서 한 줄에 표시되는 글자수를 계산 하는 코드

var textView: TextView = findViewById(R.id.textView)
val COL : Int = Math.round(textView.width / textView.paint.measureText("가나다라마.") * 6)

그런데 OnCreate에서 위 함수를 사용하면 0이 나온다.

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.textviewer)
      
        val vto: ViewTreeObserver = textView.getViewTreeObserver()
        vto.addOnGlobalLayoutListener {

            if (getWidthCount < 1) {
                getWidthCount++

                val COL : Int = Math.round(textView.width / textView.paint.measureText("가나다라마.") * 6)
                Log.i(TAG, "getWidth:" + COL)
            }
        }
    }

이 경우 위와 같이, 코드를 추가해 주면 된다.

Unit test에서 Test sample 파일을 읽어서 테스트 하는 방법

1. test 폴더에 resources 폴더를 만들고 테스트 파일을 넣는다

2. 아래와 같이 코드를 작성한다.

    @Test
    public void encrypt() throws URISyntaxException {
        File file = new File(getClass().getResource("/1.txt").toURI());
        assert(file != null);
        URL unavailableURL = getClass().getResource("/unavilable.txt");
        assert(unavailableURL == null);
    }

Android로 APK를 생성하면서 자동으로 파일 이름 생성 및 버전 명을 업데이트 하는 스크립트를 구성해 보았다

미래의 나를 위하여 기록을 남긴다

android {
    compileSdkVersion 29
    buildToolsVersion "29.0.3"

    def versionPropsFile = file('versioninfo.properties')
    def Properties versionInfo = new Properties()

    if (versionPropsFile.canRead()) {
        versionInfo.load(new FileInputStream(versionPropsFile))
    } else {
        versionInfo['VERSION_HEADER'] = "0.1105"
        versionInfo['VERSION_NUMBER'] = 0
        versionInfo['VERSION_COUNT'] = 0
        versionInfo['BUILD_COUNT'] = 0
    }

    def versionHeader = versionInfo['VERSION_HEADER']
    def versionNubmer = versionInfo['VERSION_NUMBER'].toInteger()
    def versionCount = versionInfo['VERSION_COUNT'].toInteger()
    def buildCount = versionInfo['BUILD_COUNT'].toInteger()

    def taskName = gradle.startParameter.taskNames
    def addVersion = 1
    def isReleaseVersion = false

    if (":app:bundleRelease" in taskName) {
        println '---[bundleRelease]---'
        versionNubmer += addVersion
        versionCount += addVersion
        isReleaseVersion = true
    }

    buildCount += addVersion

    versionInfo['VERSION_HEADER'] = versionHeader.toString()
    versionInfo['VERSION_NUMBER'] = versionNubmer.toString()
    versionInfo['VERSION_COUNT'] = versionCount.toString()
    versionInfo['BUILD_COUNT'] = isReleaseVersion ? "1" : buildCount.toString()

    versionInfo.store(versionPropsFile.newWriter(), null)

    def date = new Date();
    def alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    def thisYear =  alphabet.charAt(date.getYear() + 1900 - 2001)
    def thisMonth = alphabet.charAt(date.getMonth())
    def monthVersion = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ".charAt(versionCount)

    println '-------------------'
    println taskName
    println "${versionHeader}.${thisYear}${thisMonth}${monthVersion}.${buildCount}"
    println '-------------------'

    defaultConfig {
        applicationId "com.chobocho.ColorMatch"
        minSdkVersion 23
        targetSdkVersion 28
        versionCode versionNubmer
        versionName "${versionHeader}.${thisYear}${thisMonth}${monthVersion}.${buildCount}"
        setProperty("archivesBaseName", "imagematch_$versionName")
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

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

미래의 우둔한 나를 위하여, 주석을 남긴다.

android {
    compileSdkVersion 29
    buildToolsVersion "29.0.3"

    // 프로퍼티 파일 이름
    def versionPropsFile = file('versioninfo.properties')
    def Properties versionInfo = new Properties()

    if (versionPropsFile.canRead()) {
        versionInfo.load(new FileInputStream(versionPropsFile))
    } else {
        // 프로퍼티 파일이 없으면 생성을 하기위해 기본 값을 설정한다
        versionInfo['VERSION_HEADER'] = "0.1105"
        versionInfo['VERSION_NUMBER'] = 0
        versionInfo['VERSION_COUNT'] = 0
        versionInfo['BUILD_COUNT'] = 0
    }

    def versionHeader = versionInfo['VERSION_HEADER']
    def versionNubmer = versionInfo['VERSION_NUMBER'].toInteger()
    def versionCount = versionInfo['VERSION_COUNT'].toInteger()
    def buildCount = versionInfo['BUILD_COUNT'].toInteger()

    def taskName = gradle.startParameter.taskNames
    def addVersion = 1
    def isReleaseVersion = false

    // Signed APK 빌드인 경우만 versionCount를 증가 시킨다
    if (":app:bundleRelease" in taskName) {
        println '---[bundleRelease]---'
        versionNubmer += addVersion
        versionCount += addVersion
        isReleaseVersion = true
    }

    buildCount += addVersion

    // 수정된 값을 프로퍼티에 업데이트 한다
    versionInfo['VERSION_HEADER'] = versionHeader.toString()
    versionInfo['VERSION_NUMBER'] = versionNubmer.toString()
    versionInfo['VERSION_COUNT'] = versionCount.toString()
    versionInfo['BUILD_COUNT'] = isReleaseVersion ? "1" : buildCount.toString()

    versionInfo.store(versionPropsFile.newWriter(), null)

    // 빌드한 연도와 월을 남기기 위한 부분
    // 2001년 1월 > AA
    // 2020년 3월 > TC
    def date = new Date();
    def alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    def thisYear =  alphabet.charAt(date.getYear() + 1900 - 2001)
    def thisMonth = alphabet.charAt(date.getMonth())
    def monthVersion = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ".charAt(versionCount)

    println '-------------------'
    println taskName
    println "${versionHeader}.${thisYear}${thisMonth}${monthVersion}.${buildCount}"
    println '-------------------'

    defaultConfig {
        applicationId "com.chobocho.ColorMatch"
        minSdkVersion 23
        targetSdkVersion 28
        versionCode versionNubmer
        // 버전명 정보 -> 0.1105.TD1.2
        versionName "${versionHeader}.${thisYear}${thisMonth}${monthVersion}.${buildCount}"
        // 생성 되는 파일이름을 설정한다
        setProperty("archivesBaseName", "imagematch_$versionName")
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

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

지난주에 만들었던 솔리테어 게임을 Android로 포팅해 보았다.

Download:  https://play.google.com/store/apps/details?id=com.chobocho.solitaire

Java 솔리티어 게임 만들기 : https://chobocho.tistory.com/2461434?category=9608

Source code : https://github.com/chobocho/solitaire2

Android Toast Message 띄우기

안드로이드 헥사 만들기 ( Android Hexa 만들기 )

목표 : 아래와 같은 이미지의 헥사 게임을 만들어 봅시다

https://play.google.com/store/apps/details?id=com.chobocho.chobohexa

Source : https://github.com/chobocho/ChoboHexa

1. 게임 규칙

떨어지는 블럭을 잘 조절 하여, 가로, 세로, 대각선으로 같은 이미지가 3개 이상 연결 되도록 한다

2. UML 그리기

3. 동작 설명

3.1 3개이상 같은 이미지로 연결된 블럭 지우기

1) 블럭이 바닦에 닿으면, 제일 위에 블럭부터, 가로 세로 대각선으로 3개로 연속 되는 블럭이 있는지 조사합니다.

2) 떨어진 블럭을 하나이상 포함하여 3개로 연결된 블럭은 지워야할 블럭리스트에 포함을 시킵니다

3) 지워야 할 블럭 리스트에 있는 블럭을 삭제 합니다.

4) 모든 블럭에 대해서 가로, 세로, 대각선으로 3개로 연속되는 블럭이 있는지 조사하여 지워야할 블럭 리스트에 포함 시킵니다.

5) 지워야 할 블럭 리스트에 있는 블럭을 삭제 합니다.

6) 4-5의 과정을 지워야 할 블럭 리스트가 0이 될 때 까지 반복 합니다.

2018년 Toy project로 기능 추가가 쉬운(?) 테트리스를 만들어 보기로 했다.

1. 결과물

먼저 기본 기능만 동작하는 테트리스(?)의 동작 화면은 아래와 같다.

[ 다운로드 링크 ]

https://play.google.com/store/apps/details?id=com.chobocho.tetris

[ Source code ]

https://github.com/chobocho/AndroidTetris

[ Build guide ]

Guide for Android Tetris.pdf

2. 설계

먼저 구현을 위하여 아래와 같이 UML을 그렸다.

3. 상세설명

3.1 Block

Tetris는 아래 7가지 Block를 사용한다

그래서 Tetrominos 라는 추상 클래스를 만들고, 모든 블럭은 이 클래스를 상속받아서 만든다

이렇게 하면 추후 다른 모양의 블럭을 추가 하기가 쉽다.

[ Tetroinos.java ]

package com.chobocho.tetris;
import java.util.*;

public abstract class Tetrominos {
    protected int x;
    protected int y;
    protected int r;
    protected int w;
    protected int h;
    protected int type;
    protected int numOfBlockType;
    protected int[][][] block;


    public Tetrominos() {
    }

    public void rotate() {
        r = (r+1) % numOfBlockType;
    }

    public void preRotate() {
        r = (r-1+numOfBlockType) % numOfBlockType;
    }

    public void moveLeft() {
        x--;
    }

    public void moveRight() {
        x++;
    }


    public void moveDown() {
        y++;
    }

    public void moveUp() {
        y--;
    }

    public int[][] getBlock() {
        return null;
    }

    public int getWidth() {
        return w;
    }

    public int getHeight() {
        return h;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    public int getType() { return type; }
}

각각의 블록은 위 클래스를 상속받아서 구현 한다.

x, y : 블럭이 보드에 표시되는 시작 좌표

w, h : 블럭을 나타내는 배열의 크기 (블럭마다 다르다. I의 경우 4x4 지만, ㅁ의 경우 2x2 면 된다)

r : 회전한 값을 나타내기 위해 필요하다

type : 블럭의 색상을 나타내기 위해 사용한다

numOfBlock : 블럭 회전시 나타날 수 있는 모양의 수 이다.

실제 이를 상속받은 I형 블럭의 구현 클래스의 소스를 확인하면 아래와 같다

[ ITetrominos.java ]

package com.chobocho.tetris;
import java.util.*;

public class ITetrominos extends Tetrominos {

    public ITetrominos() {
        this.block = new int[][][]{
                {
                        {1, 0, 0, 0},
                        {1, 0, 0, 0},
                        {1, 0, 0, 0},
                        {1, 0, 0, 0},
                },
                {
                        {1, 1, 1, 1},
                        {0, 0, 0, 0},
                        {0, 0, 0, 0},
                        {0, 0, 0, 0},
                }
        };
        numOfBlockType = 2;
        x = 3;
        y = 0;
        r = 0;
        w = 4;
        h = 4;
        type = 1;
    }

    public int[][] getBlock() {
        return block[r];
    }
}

3.2 Tetrominos Factory

Tetris 에서 사용하는 블럭을 만들어 주는 Factory class 이다

게임에 사용되는 모든 블럭은 이 클래스를 통하여 생성한다

[ TetrominosFactory.java ]

Factory pattern을 사용하여, Tetrominos 블럭을 생성한다.

package com.chobocho.tetris;
import java.util.*;

public class TetrominosFactory {

    public static Tetrominos create() {
        switch( (int) (Math.random() * 7)) {
            case 0:
                return new OTetrominos();
            case 1:
                return new ITetrominos();
            case 2:
                return new LTetrominos();
            case 3:
                return new JTetrominos();
            case 4:
                return new TTetrominos();
            case 5:
                return new STetrominos();
            case 6:
                return new ZTetrominos();
            default:
                return new ITetrominos();
        }
    }

    private TetrominosFactory() {}
}

3.3 State

본 테트리스 게임은 4가지의 State를 가진다

1) IDLE

2) PLAY

3) PAUSE

4) GAMEOVER

[ Tetris game state chart ]

그래서 State pattern을 적용하였다.

각각의 State는 TetrisGameState를 상속받는 구조로 되어 있고, 실제 게임 동작은 TetrisPlayState에서 이루어 진다.

[ TetrisGameState.java ]

package com.chobocho.tetris;

public abstract class TetrisGameState {
    protected ITetris tetris;

    public TetrisGameState() {}

    public void init() {}

    public void rotate() {}

    public void moveLeft() {}

    public void moveRight() {}

    public void moveDown() {}

    public void fixCurrentBlock() {}

    public void moveBottom() {}

    public void updateBlock() {}

    public boolean gameOver() {
        return false;
    }

    public void updateBoard() {}

    public Tetrominos getCurrentTetrominos() {
        return null;
    }

    public Tetrominos getNextTetrominos() { return null; }

    public void update() {
        TetrisLog.d("TetrisGameState.update()");
    }
}

TetrisPlayState는 TetrisGameState를 상속받으며, 현재 블럭과 다음 블럭의 정보를 가지고 있다.

사용자가 화면을 터치하여 블럭을 움직이거나 회전을 하게 되면 블럭의 정보를 업데이트 하고

보드에 블럭정보를 업데이트 하는 동작을 한다.

블럭을 이동하고 나면 Observer pattern을 이용하여 UI 화면을 갱신한다

[ TetrisPlayState.java ]

package com.chobocho.tetris;

public class TetrisPlayState extends TetrisGameState {
    private Tetrominos currentTetrominos;
    private Tetrominos nextTetrominos;
    private TetrisBoard tetrisBoard;
    private int additionalPoint = 1;

    public TetrisPlayState(Tetris tetris, TetrisBoard board) {
        this.tetris = tetris;
        this.tetrisBoard = board;
        currentTetrominos = TetrominosFactory.create();
        nextTetrominos = TetrominosFactory.create();
    }

    public void init() {
        this.tetrisBoard.init();
        currentTetrominos = TetrominosFactory.create();
        nextTetrominos = TetrominosFactory.create();
        additionalPoint = 1;
    }

    public void update() {
       TetrisLog.d("TetrisPlayState.update()");
       tetris.getObserver().updatePlay();
    }

    public void moveLeft() {
       TetrisLog.d("TetrisPlayState.moveLeft()");
        currentTetrominos.moveLeft();
        if (tetrisBoard.isAcceptable(currentTetrominos) == false) {
            currentTetrominos.moveRight();
            TetrisLog.d("Not Accept");
        } else {
            TetrisLog.d("Accept");
        }
    }

    public void moveRight() {
        TetrisLog.d("TetrisPlayState.moveRight()");
        currentTetrominos.moveRight();
        if (tetrisBoard.isAcceptable(currentTetrominos) == false) {
            currentTetrominos.moveLeft();
            TetrisLog.d("Not Accept");
        } else {
            TetrisLog.d("Accept");
        }
    }

    public void rotate() {
        TetrisLog.d("TetrisPlayState.rotate()");
        currentTetrominos.rotate();
        if (tetrisBoard.isAcceptable(currentTetrominos) == false) {
            currentTetrominos.preRotate();
            TetrisLog.d("Not Accept");
        } else {
            TetrisLog.d("Accept");
        }
    }
    
    public void moveDown() {
        TetrisLog.d("TetrisPlayState.moveDown()");
        currentTetrominos.moveDown();
        if (tetrisBoard.isAcceptable(currentTetrominos) == false) {
            currentTetrominos.moveUp();
            TetrisLog.d("Can not move down");
            fixCurrentBlock();
            updateBoard();
            updateBlock() ;
        } else {
            TetrisLog.d("Accept");
        }
    }
    
    public void moveBottom() {
        TetrisLog.d("TetrisPlayState.moveBottom()");
        while(tetrisBoard.isAcceptable(currentTetrominos)) {
            currentTetrominos.moveDown();
        }
        if (tetrisBoard.isAcceptable(currentTetrominos) == false) {
            currentTetrominos.moveUp();
        }
    }

    public void fixCurrentBlock() {
        tetrisBoard.addTetrominos(currentTetrominos);
    }

    public void updateBlock() {
        currentTetrominos = nextTetrominos;
        nextTetrominos = TetrominosFactory.create();
    }

    public boolean gameOver() {
        TetrisLog.d("Game over!");
        return (tetrisBoard.isAcceptable(currentTetrominos) == false);
    }

    public void updateBoard() {
        int removedLine = tetrisBoard.arrange();
        int point = calculatorScore(removedLine);
        tetris.addSore(point);
    }

    private int calculatorScore(int removedLineCount) {
        if (removedLineCount == 0) {
            additionalPoint = 1;
            return 0;
        }
        if (removedLineCount >= 4) {
            removedLineCount = 4;
        }
        if (additionalPoint > 10000) {
            additionalPoint = 10000;
        }
        additionalPoint <<= removedLineCount;
        TetrisLog.d("calculatorScore : " + additionalPoint + " : " + removedLineCount);
        return  (removedLineCount * 10 * additionalPoint);
    }

    public Tetrominos getCurrentTetrominos() {
        return currentTetrominos;
    }

    public Tetrominos getNextTetrominos() {
        return nextTetrominos;
    }
}

3.4 Board

3.5 Observer pattern

3.6 Tetris

3.7 Source 코드로 부터 생성한 UML

4. Reference

* Head first design pattern

* 질문은 언제나 환영 합니다.