프로그래밍 검색 블로그

안드로이드 WebView 대신 Chrome Tab 사용

코딩조무사 — Sat, 23 Mar 2019 15:16:43 +0900

간단한 웹 브라우징 기능에 대해서는 WebView 대신 Chrome Tab 기능도 사용할 수 있어 소개 한다

최신 안드로이드 폰에서는 크롬이 설치되어 있어서 사용할 수 있을것이다

support 라이브러리에 맞는 버젼으로 build.gradle에 추가

1

implementation 'com.android.support:customtabs:28.0.0'

cs

여러가지 방법으로 CustomTab을 사용이 가능하지만 몇가지 이벤트를 전달받을 수 있도록

ServiceConnection 부분으로 사용한다

1
2
3
4
5
6
7
8
9

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        CustomTabsClient.bindCustomTabsService(
                getApplicationContext() ,
                "com.android.chrome",
                tabConnection);
    }
Colored by Color Scripter

cs

tabConnection 구현

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

 private CustomTabsServiceConnection tabConnection = new CustomTabsServiceConnection() {
     
 
        @Override
        public void onCustomTabsServiceConnected(ComponentName componentName, CustomTabsClient customTabsClient) {
            CustomTabsSession session = customTabsClient.newSession(null);
 
            CustomTabsIntent.Builder customTabsIntentBuilder =
                    new CustomTabsIntent.Builder(session);
 
            CustomTabsIntent customTabsIntent = customTabsIntentBuilder.build();
            customTabsIntent.intent.setPackage("com.android.chrome");
            customTabsIntent.intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            customTabsIntent.launchUrl(getApplicationContext(), Uri.parse("https://psbs.tistory.com"));
 
        }
 
        @Override
        public void onServiceDisconnected(ComponentName name) {
 
        }
    };
Colored by Color Scripter

cs

새로운 크롬과의 연결 session을 만들어서 launchUrl을 하는 방식으로 웹페이지 호출이 가능하다

로드 시작 이벤트, 로드 끝 이벤트를 받고 싶다면 newSesson으로 넣는 null 대신 CustomTabsCallback을 호출하는것으로 가능한데

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

            CustomTabsSession session = customTabsClient.newSession(new CustomTabsCallback(){
                @Override
                public void onNavigationEvent(int navigationEvent, Bundle extras) {
                    super.onNavigationEvent(navigationEvent, extras);
                    switch (navigationEvent) {
                        case CustomTabsCallback.NAVIGATION_STARTED:
                            Log.d("psbs", "NAVIGATION_STARTED");
                            break;
                        case CustomTabsCallback.NAVIGATION_FINISHED:
                            Log.d("psbs", "NAVIGATION_FINISHED");
                            break;
                        case CustomTabsCallback.NAVIGATION_FAILED:
                            Log.d("psbs", "NAVIGATION_FAILED");
                            break;
                        case CustomTabsCallback.NAVIGATION_ABORTED:
                            Log.d("psbs", "NAVIGATION_ABORTED");
                            break;
                    }
                }
            });
Colored by Color Scripter

cs

위의 session 생성을 이것으로 대체하는것으로 이벤트를 확인 가능해진다 

CustomTab의 메뉴 등을 추가를 위해서는 다음과 같은 코드로 추가/이벤트 핸들링이 가능하다

1
2
3
4
5

String menuItemTitle = "my menu";
            Intent actionIntent = new Intent(
                    getApplicationContext(), MainActivity.class);
            PendingIntent menuItemPendingIntent = PendingIntent.getActivity(
                    getApplicationContext(), 1, actionIntent, 0);

cs

최종 전체 소스

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

package org.example.webview;
 
import android.app.PendingIntent;
import android.content.ComponentName;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.support.customtabs.CustomTabsCallback;
import android.support.customtabs.CustomTabsClient;
import android.support.customtabs.CustomTabsIntent;
import android.support.customtabs.CustomTabsServiceConnection;
import android.support.customtabs.CustomTabsSession;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.widget.Toast;
 
public class MainActivity extends AppCompatActivity {
 
    private CustomTabsServiceConnection tabConnection = new CustomTabsServiceConnection() {
 
        @Override
        public void onCustomTabsServiceConnected(ComponentName componentName, final CustomTabsClient customTabsClient) {
            CustomTabsSession session = customTabsClient.newSession(new CustomTabsCallback(){
                @Override
                public void onNavigationEvent(int navigationEvent, Bundle extras) {
                    super.onNavigationEvent(navigationEvent, extras);
                    switch (navigationEvent) {
                        case CustomTabsCallback.NAVIGATION_STARTED:
                            Log.e("psbs", "NAVIGATION_STARTED");
                            break;
                        case CustomTabsCallback.NAVIGATION_FINISHED:
                            Log.e("psbs", "NAVIGATION_FINISHED");
                            break;
                        case CustomTabsCallback.NAVIGATION_FAILED:
                            Log.e("psbs", "NAVIGATION_FAILED");
                            break;
                        case CustomTabsCallback.NAVIGATION_ABORTED:
                            Log.e("psbs", "NAVIGATION_ABORTED");
                            break;
                    }
                }
            });
 
            CustomTabsIntent.Builder customTabsIntentBuilder =
                    new CustomTabsIntent.Builder(session);
 
            String menuItemTitle = "my menu";
            Intent actionIntent = new Intent(
                    getApplicationContext(), MainActivity.class);
            PendingIntent menuItemPendingIntent = PendingIntent.getActivity(
                    getApplicationContext(), 1, actionIntent, 0);
 
            customTabsIntentBuilder.addMenuItem(menuItemTitle, menuItemPendingIntent);
 
            CustomTabsIntent customTabsIntent = customTabsIntentBuilder.build();
            customTabsIntent.intent.setPackage("com.android.chrome");
            customTabsIntent.intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            customTabsIntent.launchUrl(getApplicationContext(), Uri.parse("https://psbs.tistory.com"));
 
        }
 
        @Override
        public void onServiceDisconnected(ComponentName name) {
 
        }
    };
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        CustomTabsClient.bindCustomTabsService(
                getApplicationContext() ,
                "com.android.chrome",
                tabConnection);
    }
}
 
Colored by Color Scripter

cs

python REST API 사용법 JSON 파싱

코딩조무사 — Thu, 21 Mar 2019 23:20:28 +0900

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import urllib.request
import json
"""
    나오는 응답 
    {'success': True, 'message': '', 'result': {'Bid': 4025.00092321, 'Ask': 4026.60175655, 'Last': 4024.00915298}}
    Bid : 살 때,
    Ask : 팔 때,
    Last : 최근 거래 가격
"""
coin_address = "https://bittrex.com/api/v1.1/public/getticker?market=USDT-BTC"
 
req = urllib.request.urlopen(coin_address)
res = req.readline()
 
j = json.loads(res)
print(j["result"]["Last"])
 
Colored by Color Scripter
cs

기본 HTTP 요청

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import urllib.request
import json
 
github_token = "token ACCESS_TOKEN"
github_address = "https://api.github.com/repos/rudty/MuteSpeakerOnHeadsetUnplugged"
 
req = urllib.request.Request(github_address, headers={
    "Authorization": github_token
})
res = urllib.request.urlopen(req)
body = res.readline()
 
j = json.loads(body)
print(j)
Colored by Color Scripter
cs

헤더 포함 

서피스 윈도우 태블릿에서 이어폰 제거 시 음소거

코딩조무사 — Sat, 16 Mar 2019 11:28:20 +0900

https://github.com/rudty/MuteSpeakerOnHeadsetUnplugged

시작프로그램에 등록하거나 윈도우 시작할때마다 실행 할 것.

go context Timeout, deadline

코딩조무사 — Sat, 22 Dec 2018 20:45:33 +0900

go 에서 기본으로 제공하고 있는 패키지 중에 다른 언어에는 기본적으로는 없는 유용한 패키지중의 하나가 context 이다

context.Background()

기본적으로 Background()를 제외한 다른 context들은 다른 context를 받는데

기능 상으로 해당 인자로 준 context를 상속 받는다고 생각하면 된다

context의 동작은 조건이 충족되지 않을 시에는 Err() 함수의 반환값을 통해서 알 수 있다

간단하게 nil이 아니면 에러

db 연결 부분은 제외하고

context만 사용하는 간단한 예제

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()
	//cancel이 3초안에 실행되지 않으면 에러

	row := db.QueryRowContext(ctx, "select 87")

	if err := ctx.Err(); err != nil {
		fmt.Println("ERROR!", err)
		return
	}

	var a int
	row.Scan(&a)
	fmt.Println(a)
}

출력 87

db에 연결후 87의 값을 꺼내온다

쿼리에는 에러가 없어 ctx.Err()는 체크되지 않고 넘어간다

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()
	//cancel이 3초안에 실행되지 않으면 에러

	row := db.QueryRowContext(ctx, "WAITFOR DELAY '0:0:5'")

	if err := ctx.Err(); err != nil {
		fmt.Println("ERROR!", err)
		return
	}

	var a int
	row.Scan(&a)
	fmt.Println(a)
}

출력 ERROR! context deadline exceeded

쿼리로 5초간 정지 했을 때는 3초안에 끝나지 못했으므로

에러가 발생한다

context를 인자로 받는 함수 생성

func sumWithContext(c context.Context, a, b int) (result int) {
	//받은 context를 바탕으로 새 context 생성
	ctx, cancel := context.WithCancel(c)
	go func() {
		defer cancel()
		result = a + b
	}()
	//계산이 끝나거나 부모 context 에서 에러 검사
	<-ctx.Done()
	return
}

기능은 간단하게 a + b를 하는 함수이다

인자로 받는 함수 생성 시에는 어떤 context가 들어올지 알 수 없으므로

일단 주어진 context를 바탕으로 cancel이 가능한 context를 생성한다

그 후 다른 go루틴을 통해서 계산을 진행한다

이때 a + b의 작업이 오래 걸린다고 해서 해당 go루틴이 종료되진 않지만

sumWithContext를 호출한 함수는 제한을 건 조건 안에 응답을 받을 수 있다

코틀린 파일 MD5 SHA1 SHA256 SHA512

코딩조무사 — Wed, 30 May 2018 23:11:51 +0900


	import java.io.File import java.io.FileInputStream
	import java.security.MessageDigest
	import javax.xml.bind.DatatypeConverter

	fun digest(file: File, engine: String) : String{
	val md = MessageDigest.getInstance(engine)

	FileInputStream(file).use { fi ->
	val bytes = ByteArray(4096)

	while (true) {
	val length = fi.read(bytes)

	if (length <= 0) {
	break
	}

	md.update(bytes, 0, length)
	}


	val byteData = md.digest()


	return DatatypeConverter.printHexBinary(byteData)
	}
	}

	fun getMD5(file: File) = digest(file,"MD5")
	fun getSHA1(file: File) = digest(file,"SHA1")
	fun getSHA256(file: File) = digest(file,"SHA-256")
	fun getSHA512(file: File) = digest(file,"SHA-512")





	fun main(args: Array<String>) {

	val file = File("test.txt")
	println(getMD5(file))
	println(getSHA1(file))
	println(getSHA256(file))
	println(getSHA512(file))
	}

go AES 암호화

코딩조무사 — Tue, 22 May 2018 14:05:07 +0900

package main

import (
	"crypto/aes"
	"crypto/cipher"
	"crypto/rand"
	"encoding/base64"
	"fmt"
	"io"
)

type AESCipher struct {
	block cipher.Block
}

func NewAesCipher(key []byte) (*AESCipher, error) {
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}
	return &AESCipher{block}, nil
}

func (a *AESCipher) EncryptString(s string) string {
	byteString := []byte(s)
	encryptByteArray := make([]byte, aes.BlockSize+len(s))

	iv := encryptByteArray[:aes.BlockSize]

	io.ReadFull(rand.Reader, iv)

	stream := cipher.NewCFBEncrypter(a.block, iv)
	stream.XORKeyStream(encryptByteArray[aes.BlockSize:], byteString)

	return base64.URLEncoding.EncodeToString(encryptByteArray)
}

func (a *AESCipher) DecryptString(base64String string) string {

	b, _ := base64.URLEncoding.DecodeString(base64String)
	byteString := []byte(b)

	decryptByteArray := make([]byte, len(byteString))
	iv := byteString[:aes.BlockSize]

	stream := cipher.NewCFBDecrypter(a.block, iv)
	stream.XORKeyStream(decryptByteArray, byteString[aes.BlockSize:])

	return string(decryptByteArray)
}

func main() {
	//키는 16, 24, 32만 가능합니다
	var key = []byte("the_key_hello_wo")

	a, _ := NewAesCipher(key)
	e := a.EncryptString("Hello World!Hello World!Hello World!Hello World!Hello World!Hello World!Hello World!Hello World!Hello World!")
	fmt.Println(e)
	d := a.DecryptString(e)

	fmt.Println(d)

}

AES 암호화 -> Base64 인코딩

디코딩

go reflect 호출

코딩조무사 — Tue, 15 May 2018 22:15:21 +0900

package main

import (
	"fmt"
	"reflect"
)

type controller struct {
}

func (c controller) Foo(a int, b string) string {
	fmt.Println("Foo")
	return fmt.Sprint(a, b)
}
func (c controller) Koo(a int, b string) string {
	fmt.Println("Koo")
	return fmt.Sprint(a, b)
}

func (c controller) goo() {
	//private는 안보임
}

//reflection으로 함수 호출할때는 일반 인자 대신 reflect.Value를 넣는다
func valueToReflectionArguments(args ...interface{}) []reflect.Value {
	length := len(args)
	reflectArgs := make([]reflect.Value, 0, length)
	for i := 0; i < length; i++ {
		reflectArgs = append(reflectArgs, reflect.ValueOf(args[i]))
	}
	return reflectArgs
}

func main() {

	c := controller{}

	//포인터를 넘기고 싶다면 reflect.TypeOf(&c)
	myType := reflect.TypeOf(c)

	//메서드 모두 호출
	//혹은 myType.MethodByName으로 이름으로 검색
	//Public멤버만 검색하고 한글 시작은 private이 됨
	for i := 0; i < myType.NumMethod(); i++ {
		method := myType.Method(i)
		ret := method.Func.Call(valueToReflectionArguments(c, 3, "test"))
		fmt.Println(ret[0].String())
	}
}

go 파일 압축

코딩조무사 — Sat, 12 May 2018 16:54:13 +0900

package main

import (
	"archive/zip"
	"io"
	"io/ioutil"
	"os"
	"path/filepath"
)

// ZipDir 폴더를 지정해서 그 폴더 안에 있는 파일들을
// saveFile에 저장합니다
// error nil 압축성공
// 그외: 압축 실패
func ZipDir(saveFile *os.File, savePath string) error {
	zipWriter := zip.NewWriter(saveFile)
	defer zipWriter.Close()
	z := zipType{zipWriter}
	return z.dir(savePath, "")
}

func main() {
	//실행 파일과 같은 위치에 있는 test폴더 안에 있는 요소를
	//result.zip으로 압축합니다.

	newfile, err := os.Create("result.zip")
	if err != nil {
		panic(err)
	}

	ZipDir(newfile, "test")
}

type zipType struct {
	writer *zip.Writer
}

//dir 폴더 안을 zip 안에 넣기 위해서 dir과 다른 경로를 가짐
func (z zipType) dir(dirPath string, zipPath string) error {
	files, err := ioutil.ReadDir(dirPath)
	if err != nil {
		return err
	}
	for _, file := range files {
		fullPath := dirPath + string(filepath.Separator) + file.Name()
		if file.IsDir() {
			if err != nil {
				return err
			}
			z.dir(fullPath, zipPath+file.Name()+string(filepath.Separator))
		} else {
			if err := z.file(file, fullPath, zipPath); err != nil {
				return err
			}
		}
	}
	return nil
}

func (z zipType) file(file os.FileInfo, filePath string, zipPath string) error {
	header, _ := zip.FileInfoHeader(file)
	header.Name = zipPath + header.Name

	w, err := z.writer.CreateHeader(header)
	if err != nil {
		return err
	}
	f, err := os.Open(filePath)
	if err != nil {
		return err
	}
	defer f.Close()
	io.Copy(w, f)

	return nil
}

코틀린 비동기 async

코딩조무사 — Fri, 16 Feb 2018 19:41:15 +0900

코틀린 베타로 비동기 관련 Api 가 추가되었다

문법으로는 C#의 async/await의 코틀린식 구현이라고 볼수 있다

베타를 비동기 Api를 사용하기 위해 그레들 설정부터 보자면

현재 코틀린 버전을 1.2.21 혹은 그 이상으로 맞춰준다

1
ext.kotlin_version = '1.2.21'
cs

dependencies에 코루틴 api 를 추가한다

현재는 베타라서 필요하지만 미래에는 필요 없을수도 있다

1
compile "org.jetbrains.kotlinx:kotlinx-coroutines-core:0.22.2"
cs

1. 비동기 API

async 는 비동기로 동작하고 블럭 안에 있는 것을 비동기로 수행한다

간단하게 textview 글자를 바꿔주는걸로 시작해본다

launch 도 비슷한 기능을 수행하지만 코틀린 공식 홈페이지에 존재하지 않아서

앞으로 삭제될 가능성이 있어 적지 않았다

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
 
 
        async {
            //Thread.sleep
            Log.e(TAG,"before")
            delay(5000)
            //비동기라서 View.post 를 호출해서 구현해야 한다
            textView.post {
                textView.text = "call async"
            }
            Log.e(TAG,"after")
        }
    }
Colored by Color Scripter
cs

2. 비동기 함수

직접 비동기 함수를 만들려고 한다면 바로 async를 반환하는 방법으로 만들수 있다

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
    fun calc() = async {
        delay(3000)
        val s = (1..1000).sum()
        return@async s
    }
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
 
 
        async {
            val executeSum = calc()
            Log.e(TAG,"before")
            delay(5000)
            val sum = executeSum.await()
            textView.post {
                //비동기라서 View.post 를 호출해서 구현해야 한다
                textView.text = "call async" + sum
            }
            Log.e(TAG,"after")
        }
    }
Colored by Color Scripter
cs

val executeSum = calc()이 호출된 후 before 로그가 찍히고

val sum에서 Int를 받은 후에 textView에 찍게 된다

3. 동기적인 함수에서 비동기 호출 계산을 끝내기

계산 결과를 출력하기 위해서 동기적인 함수에서 비동기 작업들을 일괄적으로 끝내야 할 때가 있는데

그때 함수의 앞에 suspend 키워드를 사용한다

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
    suspend fun calc() : Int{
        val c = async {
            delay(3000)
            val s = (1..1000).sum()
            return@async s
        }
        return c.await()
    }
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
 
 
        async {
 
            Log.e(TAG,"before")
            delay(5000)
            val sum = calc()
            textView.post {
                //비동기라서 View.post 를 호출해서 구현해야 한다
                textView.text = "call async" + sum
            }
            Log.e(TAG,"after")
        }
    }
Colored by Color Scripter
cs

안드로이드 SQLite 사용 Create, Index

코딩조무사 — Mon, 12 Feb 2018 00:48:43 +0900

기본적인 안드로이드의 SQLite 사용법과

table 구성, 그리고 인덱스까지 알아본다

일단 테이블 구성은

Bread (name, price)로 만들어보았다

테이블 생성 후 인덱스를 생성하여

대용량 데이터베이스가 들어가도 문제가 없다

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
package com.example.d.sqliteexample;
 
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log;

 
import java.util.ArrayList;
import java.util.List;
 
 
public class BreadSqlHelper extends SQLiteOpenHelper{
    private static final int DB_VERSION = 1;
    private static final String DB_NAME = "Bread";
 
    private static class Bread{
        /**
         * 내부적으로 사용하는 Bread
         */
        String name;
        int price;
 
        Bread(String name, int price) {
            this.name = name;
            this.price = price;
        }
    }
 
    public BreadSqlHelper(Context context) {
        super(context, DB_NAME, null, DB_VERSION);
    }
 
    @Override
    public void onCreate(SQLiteDatabase db) {
        //빵과 관련한 테이블을 만듭니다
        //아이디,
        //이름,
        //가격으로 구성하였으며 아이디 값은 자동 증가입니다
        db.execSQL("create table if not exists bread (_id integer primary key autoincrement, name text, price integer)");
 
        //이름으로만 가져오는 인덱스를 만듭니다 이름은 고유합니다
        db.execSQL("create unique index if not exists bread_id on bread(name)");
 
        //전체 목록을 가져오는 인덱스를 만듭니다
        db.execSQL("create index if not exists bread_id_name_price on bread(_id, name, price)");
    }
 
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        if(oldVersion < newVersion){
            //업그레이드 할때 하는 작업
            final ArrayList<Bread> tempList = new ArrayList<>();
 
            //1. 기존 데이터 tempList 에 저장
            try(Cursor cursor = db.rawQuery("select name, price from bread", null)){
                String name = cursor.getString(1);
                int price = cursor.getInt(1);
                tempList.add(new Bread(name, price));
            }
 
 
            //기존 db 제거
            db.rawQuery("drop index bread_id", null);
            db.rawQuery("drop index bread_id_name_price", null);
            db.rawQuery("drop table bread", null);
 
            //db 생성 작업 실행
            onCreate(db);
 
 
            //새로운 db 에 추가
            //db 가 변경점이 생겼을 때 하는 작업이므로
            //변경을 거쳐서 아래에 추가할 것.
            //
            //beginTransaction 안에서 insert 를 하게 되면 전반적인 성능이 올라갑니다
            db.beginTransaction();
            try {
                for (Bread b : tempList) {
                    Log.i("BreadSqlHelper", b.name + " " + b.price);
                    //여기에 추가하세요
                    //db.rawQuery("insert into bread.... ")
                }
                db.setTransactionSuccessful();
            }
            finally {
                db.endTransaction();
            }
 
        }
    }
}
 
Colored by Color Scripter
cs

MainActivity 구성은 사용해본걸 출력하는걸로 만들어보았다

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
package com.example.d.sqliteexample;
 
import android.content.ContentValues;
import android.database.Cursor;
import android.database.sqlite.SQLiteStatement;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.TextView;
 
public class MainActivity extends AppCompatActivity {
 
    private BreadSqlHelper breadDb;
    private TextView textView;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textView = (TextView)findViewById(R.id.textView);
 
        breadDb = new BreadSqlHelper(getApplicationContext());
 
        //반복 테스트를 하고 있으므로 실행시마다 전부 삭제
        breadDb.getWritableDatabase().execSQL("delete from bread");
 
 
        //기본 SQL 로 inset를 합니다
        breadDb.getWritableDatabase().execSQL("insert into bread(name, price) values('소보루빵', 1000)");
 
        ContentValues insertValue = new ContentValues();
        insertValue.put("name", "팥빵");
        insertValue.put("price", 300);
        breadDb.getWritableDatabase().insert("bread","", insertValue);
 
        //미리 컴파일된 sql 을 만들고 실행합니다
        //실행후 끝내는것이 아니라 close 만 호출하지 않는다면 bind 만 바꿔서 재실행이 가능합니다
        //1부터 시작합니다
        SQLiteStatement statement = breadDb.getWritableDatabase().compileStatement("insert into bread(name, price) values(?, ?)");
        statement.bindString(1, "붕어빵");
        statement.bindLong(2, 200);
        statement.executeInsert();
        statement.close();
 
 
 
        //db의 모든 원소들을 출력합니다
        //놀랍게도 여긴 0부터 시작합니다
        StringBuffer print = new StringBuffer();
        try(Cursor cursor = breadDb.getReadableDatabase().rawQuery("select * from bread", null)){
            while(cursor.moveToNext()){
                print.append(cursor.getString(0))
                        .append(" ")
                        .append(cursor.getString(1))
                        .append(" ")
                        .append(cursor.getString(2))
                        .append("\n");
            }
        }
 
        textView.setText(print.toString());
 
 
    }
}
 
Colored by Color Scripter
cs