TextView에서 터치된 영역의 Offset 가져오기

Posted by Find my true self Fimtrus
2011.08.24 09:16 Programming/Android
Ebook 관련 API들을 만들고 테스트하는 도중,
Select에서의 블록이나 하이라이트와 관련해서
터치된 영역이 문자열의 어느 부분인지 구하는 로직이 필요했습니다.

물론 Paint를 써서 대충 계산하면 어느정도 맞출 수는 있지만
문자 사이즈에 의해 정해져있는 세로와는 달리 가로는 폰트마다
가변적인 사이즈를 가지고 있기 때문에 폰트마다
일일히 계산해주지 않으면 안 되는 상황에 봉착했습니다.
(예전에는 폰트 매트릭스를 읽어와 일일히 계산해주었다는군요)

그러다가 웹서핑 도중 유용한 녀석을 발견해서 정리해놓습니다.
아직도 모르는 게 너무도 많아서 문제군요

public int getOffset(TextVIew text, MotionEvent event) {
  // 터치 좌표를 int형으로 바꿔준다.
  int positionX = (int) event.getX();
  int positionY = (int) event.getY();


  // TextView의 Padding값을 빼준다. (text 영역안에서 계산하기 위함)
    positionX -= text.getTotalPaddingLeft();
    positionY -= text.getTotalPaddingTop();


// TextView의 레이아웃을 가져온다.
    Layout layout = text.getLayout();


// Y좌표를 이용, 현재 몇번째 Line인지 계산한다.
    int line = layout.getLineForVertical(positionY);


 // 라인과 X좌료를 이용, 현재 터치한 영역의 Offset을 구한다.
    int off = layout.getOffsetForHorizontal(line, positionX);


    // 계산된 결과를 리턴
    return off;
}


출처 : http://chunic.blogspot.com/2011/07/textview-offset.html
이 댓글을 비밀 댓글로

What is android??

Posted by Find my true self Fimtrus
2011.07.05 09:52 Programming/Android

안드로이드는 모바일 디바이스를 위한 소프트웨어Stack 입니다.
안드로이드 SDK를 통해 Java 언어를 이용하여 Application을 개발합니다.

Android Architecture



Applications


안드로이드는 E-mail, SMS, Calender, browser, Contacts 등과 같은 Application을 탑재하고 있습니다. 모든 Application은 Java 로 작성되어있습니다.
  • 모든 Application은 가상머신에 대한 자신의 인스턴스를 가지고, 자신의 프로세스 내에서 실행된다.
  •  모든 Application은 동등한 입장으로 실행된다. 즉, 기본 시스템 대신, 직접만든 시스템을 초기화면으로 사용가능하다.


Applications Framework


말 그대로 번역하면 "사용할 수 있는 틀"이다. 기존에 만들어진 틀을 이용해 개발자들이 보다 편리하고 고성능의 Application을 개발할 수 있도록 지원하는 역할을 한다.

  • 개발자들을 위한 자원들이다. 이것을 통해 모든 Application을 개발할 수 있다.
  • User를 위한 UI 제작
  • data에 접근하기 위한 Content Provider가 있다.
  • 알림, 라이프사이클 관리
  • 여러가지 보안제약이 따른다.


Libraris

C,C++로 코딩되어 있고, 각 회사마다 사용되는 하드웨어를 지원하기 위해 업체에서 미리 스마트폰에 설치된다.

  • 라이브러리는 Applications Framework를 통해 개발자들에게 제공된다
  • 안드로이드는 임베디드 리눅스 기반의 디바이스에 적합하도록 표준 C시스템 라이브러리를 제공한다.
  • 미디어 라이브러리를 통해 여러가지 오디오, 비디오 포맷을 제공한다.
  • 그외 SurfaceManager, LibWebCore, SQLite 등이 있다.


Android Runtime

Java 프로그래밍 언어의 핵심 라이브러리에서 사용가능한 기능들을 포함하고 있다.  Core Library를 통해 Java의 핵심 라이브러리 기능을 사용할 수 있다.

* Runtime : 컴퓨터 프로그램이 실행되고 있는 동안의 동작을 말한다.

  • Dalvik VM
    • Java 컴파일된 클래스 실행
    • Dalvik 가상머신의 실행 파일인 dex 포맷을 사용한다.
    • Threading과 Low-level 메모리 관리는 Linux Kernel에 의존한다.
  • Core Library
    • Android에서 Java 프로그래밍을 위한 핵심 라이브러리이다.


Linux Kernel

안드로이드는 보안, 메모리 관리, 프로세스 관리, 네트워킹 등의 시스템 서비스를 제공한다.
즉, 부팅, 파일시스템, 하드웨어 제어를 위한 디바이스 드라이버 등이 여기에 해당한다.



 


 

이 댓글을 비밀 댓글로

interface 와 추상클래스

Posted by Find my true self Fimtrus
2011.06.24 12:41 Programming/Java
인터페이스와 추상클래스에 관해 간단히 설명하고 넘어가겠다.

interface    : 상수와 추상메소드로 구성된다. 
추상클래스 : 속성, 상수, 일반메소드, 추상메소드를 포함할 수 있고, 객체화가                     불가능하다.


interface 구현방법

접근지정자 interface 인터페이스명 {
상수;
추상메소드;
 

ex) 

예를들어 도형이라느 인터페이스는 구현한다고 하면,

public interface 도형{
static final double PI=3.14
double getSize();
            String getName();
 

PI라는 변하지 않는 static final 형태의 상수를 정의하고,
넓이는 구하는  getSize(),getName() 라는 추상메소드를 정의한다.

abstract public double getSize();

라고 정의해도된다.


추상클래스

abstract 접근지정자 class 클래스 extends 부모 implements 인터페이스명{

            속성;
상수;
일반메소드;
추상메소드;

}

추상클래스를 구현할 때에는 반드시 접근지정자를 public 으로 해줘야한다.
왜냐하면 하위클래스에서 Override를 통해 구현해야하기 때문이다.

도형을 implement 하는 추상클래스를 만들어보자.

ex)

abstract public class abstract도형 implements 도형{
        //속성정의
        double baseLine; 
double height;  
        abstract public String PrintState(){

                 System.out.println("넓이 : "+getSize());
                 System.out.println("이름 : "+getName());

        }
 
}

도형을 상속받고, 밑변과 높이라는 속성을 정의하였다.
그리고 상태를 받아오는 PrintState() 메소드를  정의하였다.
PrintState()에서 getSize()와 getName() 을 사용할 수 있는 이유는
implements 해줬기 때문이다.


abstract도형을 상속함으로써 추상클래스내의 속성들을 사용할 수 있고, 인터페이스를 메소드 들을 Override해서 구현하여 메소드를 완성할 수 있다.

삼각형이라는 클래스를 만들었다고 가정하였을 때 
abstract도형을 상속받음으로서 도형의 모든 특징들을 가질 수 있다.
추상메소드로 정의된 메소드들을 삼각형이라는 클래스에서 구체화를 해주게 되면 클래스는 완성이 된다.

ex)

class 삼각형 extends abstract도형{
@Override
            double getSize(){
                      return baseLine*height/2;
            }
            @Override
            String getName(){
                     return "삼각형";
            }


위와 같이 인터페이스의 추상메소드를 오버라이딩하여 구체화 하게되면 사용자가 사용할 수 있는 클래스가 된다. 이를 객체화하여 사용할 수 있게 된다.


 






 

'Programming > Java' 카테고리의 다른 글

interface 와 추상클래스  (0) 2011.06.24
이 댓글을 비밀 댓글로

남해

Posted by Find my true self Fimtrus
2011.06.24 11:44 Photo/정종현


'Photo > 정종현' 카테고리의 다른 글

남해  (0) 2011.06.24
이 댓글을 비밀 댓글로

SHA-512 해시 알고리즘을 이용한 공유키 기반 암호화 시스템

Posted by Find my true self Fimtrus
2011.06.24 11:14 Programming/C/C++
main.c
===============================================
 
#include "AppLE-C.h"
int main(int argc, BYTE** argv){
 int select=0, a=0;
 //FILE* fi;// Input file pointer, 
 //FILE* fo;// Output file pointer,

 //printf("숫자를 입력하세요 : ");
 //scanf("%d", &select);
 
 
 while(1){
 printf("========================================================\n");
 printf("================ AppLE  암복호화 시스템 ================\n");
 printf("========================================================\n");
 printf("=                                                      =\n");
 printf("=           종료 <0>, 암호화 <1>, 복호화<2>            =\n");
 printf("=                                                      =\n");
 printf("=                                                      =\n");
 printf("=                                        AppLE_ver_1.0 =\n");
 printf("========================================================\n\n");
 printf("숫자를 입력하세요 : ");
  scanf("%d", &select);
  switch(select){

  case 0 :
   printf("프로그램을 종료합니다.\n");
   break;
  case 1 :
   printf("암호화를 시작합니다\n");
   printf("Plain Text file : %s\nEncryption text file : %s\nkey : %s\n\n", argv[1], argv[2], argv[3]);
   Calculation(argv[1], argv[2], argv[3]); 
   printf("====== 암호화가 완료 되었습니다. ======\n");
   printf("====== [%s]에서 확인 하세요. ======\n", argv[2]);
   break;
  case 2 :
   printf("복호화를 시작합니다\n");
   printf("Encryption text file : %s\nDecryption text file : %s\nkey : %s\n\n", argv[1], argv[2], argv[3]);
   Calculation(argv[1], argv[2], argv[3]); 
   printf("====== 복호화가 완료 되었습니다. ======\n");
   printf("====== [%s]에서 확인 하세요. ======\n", argv[2]);  
   break;
  default :
   printf("잘못입력하셨습니다. 다시입력해주세요\n\n"); 
   //break;
  }
  if(select>-1&&select<3) break;
 }
 return 0;
}
 
 
calculation.c
========================================================
#include 
#include 
#include "AppLE-C.h"
//#include "Key_Gen.h"
void Calculation(BYTE* input, BYTE* output, BYTE* key){
 BYTE* seckey;
 BYTE* buf_t;
 BYTE* f_text;//완료된 텍스트
 int strlength=0;
 int i;
 FILE* fi;
 FILE* fo;
 
 LARGE_INTEGER ticksPerSecond;
 LARGE_INTEGER start_ticks, end_ticks, diff_ticks;

 QueryPerformanceCounter(&start_ticks);
 
 
 //printf("111111\n");
 fo=fopen(output, "wb");
 
 if((fi=fopen(input, "rb"))==NULL){
  printf("Input File open Err!!\n");
  exit(1);
 }
 fseek(fi, 0, SEEK_END);
 strlength=ftell(fi);
 buf_t=(BYTE*)malloc(sizeof(BYTE)*(strlength+1));
 seckey=(BYTE*)malloc(sizeof(BYTE)*(strlength+1));
 memset(seckey, 0, sizeof(BYTE)*(strlength+1));
 memset(buf_t, 0, sizeof(BYTE)*(strlength+1));
 fseek(fi, 0, SEEK_SET);
 
 
 while(!feof(fi)){
  fread(buf_t, sizeof(BYTE), strlength, fi);
 } 
 fclose(fi);
 //printf("============== 파일에서 읽은 BUF ================\n");
 //for(i=0;i
 // printf("%x ", buf_t[i]);
 //printf("\n==================================================\n\n");
 
 buf_t[strlength]='\0';
 
 //---키젠 실행부분--
 Key_Gen(key, seckey,strlength);
 QueryPerformanceCounter(&end_ticks);
 QueryPerformanceFrequency(&ticksPerSecond);
  //printf ("ticksPerSecond: %I64Ld\n",ticksPerSecond.QuadPart);
  diff_ticks.QuadPart = end_ticks.QuadPart- start_ticks.QuadPart;
 //printf ("ticks: %I64Ld\n",diff_ticks.QuadPart);

 
 printf("=============== Keystream (seckey) ===============\n");
 for(i=0;i
  if(i%16==0)
   printf("\n");
  printf("%x ", seckey[i]);
 
 }
 printf("\n==================================================\n\n");
 
 
 printf("==================================================\n");
 printf("난수생성시간 :   %.12f  sec\n",
 ((double)diff_ticks.QuadPart/(double)ticksPerSecond.QuadPart));
 printf("\n==================================================\n\n");
 
 f_text=(BYTE*)malloc(sizeof(BYTE)*strlength+1);

 for(i=0;i
 
  f_text[i]=seckey[i]^buf_t[i] ;
  
 }
 f_text[strlength]='\0';
 //for(i=0;i
 // fputc(buf_t, fo);
 fwrite(f_text, sizeof(BYTE), strlength, fo);
 //printf("=============== XOR 연산후 BUF ===================\n");
 //for(i=0;i
 // printf("%X ", f_text[i]);
 //printf("\n==================================================\n\n");
 fclose(fo);
}
 
 
Key_Gen.c
================================================================
#include "AppLE-C.h"
#include "Key_Gen.h"
//Initial MD value

void Key_Gen(BYTE* key, BYTE* seckey, int strlength)
{
 BYTE kbuf[128]={0, };
 BYTE k_strlen[8]={0, };
 BYTE hashtobyte[8][8]={0, };
 BYTE hashbuf[64]={0,};
 int blocksize=0;
 int count=0;
 int i, j, block=0;
 WORDS final_hash[8]={0, };
 WORDS* exword;
 WORDS str;
 exword=(WORDS *)malloc(sizeof(WORDS)*80);
 //printf("kbuf : ");
 for(i=0;i<(strlen(key));i++){
  kbuf[i]=key[i];
  //printf("%x ", kbuf[i]); 
 }
 //printf("\n ");

 str=i*8;
 //padding
 kbuf[i]=0x80;
 //----strlenth
 WordtoByte(str, k_strlen);
 for(i=0;i<8;i++)
  kbuf[120+i]=k_strlen[i];
 WordEx(kbuf, exword);
 Round(exword, block, final_hash);
 for(i=0;i<8;i++){
  WordtoByte(final_hash[i], hashtobyte[i]);
  //printf("final_hash : %llx\n", final_hash[i]);
 }
 //printf("hashbuf : ");
 for(i=0;i<8;i++){
  for(j=0;j<8;j++){
   hashbuf[i*8+j]=hashtobyte[i][j];
   //printf("%x ", hashbuf[i*8+j]);}
  }
  //printf("\n");
   
 }
 KeyArr(hashbuf, seckey, strlength);
}
// Word Extention
void WordEx(BYTE* bufs, WORDS* Word){
 int r;
 int i;
 BYTE temp[8]={0, };
 WORDS temp1=0;
 WORDS wtemp=0, wtemp1=0,wtemp2=0,wtemp3=0;
 //printf("WordEx : %s", buf);
 for(r=0;r<80;r++){
  if(r<16){
   for(i=0;i<8;i++)
    temp[i]=bufs[r*BLOCKSIZE+i];
   BytetoWord(temp, &temp1);
   Word[r]=temp1;
   memset(temp, 0, sizeof(temp));
   temp1=0;
  }
  else if(r>15){

   wtemp=Word[r-16];
   //Rotate shift l-m-n
   wtemp1=RotShift1(Word[r-15]);  
   wtemp2=Word[r-7];
   wtemp3=RotShift2(Word[r-2]);
   Word[r]=wtemp^wtemp1^wtemp2^wtemp3;
  }
  //printf("round %d : %llx\n", r, Word[r]);  
 }
}
 
//--buf의 byte 8을 Word(64bits) 로 변환
void BytetoWord(BYTE* p, WORDS* word){
 int i;
 for(i=0; i<8; i++){
  *word |= (WORDS)p[i] << (56-(i*BLOCKSIZE));
 }
 //getAbit2(" byte to word :", *word, 64);
}

void getAbit2(char* a, WORDS x, int bit) { // 
 int n=0;
 WORDS mask= 0x8000000000000000;
 printf("%s\n", a);
 for(n=0; n
  if((x & (mask >> n))>0)
   printf("1");
  else
   printf("0");
 }
 printf(" ");
 printf("\n");
}
 
void Round(WORDS* word, int block, WORDS* hash){
 WORDS at=0, bt=0, ct=0, dt=0, et=0, ft=0, gt=0, ht=0;
 WORDS a1=0, b1=0, c1=0, d1=0, e1=0, f1=0, g1=0, h1=0;
 WORDS xo, yo, maj, rot,con;
 int round;

 for(round=0;round<80;round++){
  if(round==0){
   at=0x6a09e667f3bcc908;
   bt=0xbb67ae8584caa73b;
   ct=0x3c6ef372fe94f82b;
   dt=0xa54ff53a5f1d36f1;
   et=0x510e527fade682d1;
   ft=0x9b05688c2b3e6c1f;
   gt=0x1f83d9abfb41bd6b;
   ht=0x5be0cd19137e2179;
  }
  
  b1=at;
  c1=bt;
  d1=ct;
  f1=et;
  g1=ft;
  h1=gt;
  maj=(WORDS)Majority(at, bt, ct);
  //printf("maj : %llx", maj);
  rot=Rotate(at, 28, 34, 39);
  //printf("rot : %llx", rot);
  a1=(maj+rot);
  rot=0;

  con=(WORDS)Conditional(et, ft, gt);
  rot=Rotate(et, 14, 18, 41);
  e1=(ht+con+rot+word[round]+K[round]);
  //x
  xo=(a1+e1);
  //y
  yo=(e1+dt);
  at=xo;
  bt=b1;
  ct=c1;
  dt=d1;
  et=yo;
  ft=f1;
  gt=g1;
  ht=h1;
 }
 
 hash[0]=(at+a);
 hash[1]=(bt+b);
 hash[2]=(ct+c);
 hash[3]=(dt+d);
 hash[4]=(et+e);
 hash[5]=(ft+f);
 hash[6]=(gt+g);
 hash[7]=(ht+h);
 
 

}

int qwer(int a){
 int count=0;
 while(1){
  a/=2;
  if(a<2){
   break;
  }
  count++;
 }
 return count;
}  

void WordtoByte(WORDS str, BYTE* out){
 int i;
 WORDS mask = 0xFF00000000000000;
 //printf("word to str : %llx\n", str);
 for(i=0; i<8; i++){
  out[i] = (str & (mask >> (i*BLOCKSIZE))) >> (56-(i*BLOCKSIZE));
  //printf("word to byte : %x\n", out[i]);
  //printf("final_hash : %llx\n", out[i]);
 }
}
void KeyArr(BYTE* hash , BYTE* seckey, int strlength){
 int i;
 BYTE* temp;
 temp=(BYTE*)malloc(sizeof(BYTE)*(strlength+1));

 for(i=0;i
  //printf("hash : %x\n", hash[i%64]);
  hash[i%64]=RotShift1(hash[i%64]);
  temp[i]=hash[i%64];
  //printf("%d, temp : %x, hash : %x ", i, temp[i], hash[i%64]);
  seckey[i]=Makekey(temp[i], i%7);
  //printf("%x \n", seckey[i]);
 }
 //printf("Sec key Length : %d\n",strlength);
 
}
 
main.h
======================================================
#ifndef __HEADER__
#define __HEADER__
#include 
#include 
#include 
#include 
#include

typedef unsigned char BYTE;
typedef unsigned long long WORDS;
void Calculation(BYTE* input, BYTE* output, BYTE* key);
void Key_Gen(BYTE* key, BYTE* seckey, int strlength);
 
#endif
 
Key_Gen.h
=========================================================
#ifndef __KEYGEN__
#define __KEYGEN__
//Conditional
#define Conditional(x,y,z) (((x) & (y)) ^ (~(x) & (z)))
//Majority
#define Majority(x,y,z) (((x) & (y) ) ^ ((x) & (z)) ^ ((y) & (z)))
//Rotate
#define RotR(in, value) ((in<<(64-value)) | (in>>value)) 
#define Rotate(in, i, j, k) (RotR(in, i) ^ RotR(in, j)^ RotR(in, k))
 
//shift Left
//*****
#define  ShiftL(in, value) (in<
//ROtate Word
#define RotShift1(in) (RotR(in, 1) ^ RotR(in, 8) ^ ShiftL(in, 7))//
#define RotShift2(in) (RotR(in, 19) ^ RotR(in, 61) ^ ShiftL(in, 6))
#define BUFSIZE 128
#define BLOCKSIZE 8
#define Makekey(in, value) ((in<<(8-value))|(in>>value))

WORDS a=0x6a09e667f3bcc908;
WORDS b=0xbb67ae8584caa73b;
WORDS c=0x3c6ef372fe94f82b;
WORDS d=0xa54ff53a5f1d36f1;
WORDS e=0x510e527fade682d1;
WORDS f=0x9b05688c2b3e6c1f;
WORDS g=0x1f83d9abfb41bd6b;
WORDS h=0x5be0cd19137e2179;
//Key
  
/* initial key value */
WORDS K[80] = {
 0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f,
 0xe9b5dba58189dbbc, 0x3956c25bf348b538, 0x59f111f1b605d019,
 0x923f82a4af194f9b, 0xab1c5ed5da6d8118, 0xd807aa98a3030242,
 0x12835b0145706fbe, 0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2,
 0x72be5d74f27b896f, 0x80deb1fe3b1696b1, 0x9bdc06a725c71235,
 0xc19bf174cf692694, 0xe49b69c19ef14ad2, 0xefbe4786384f25e3,
 0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65, 0x2de92c6f592b0275,
 0x4a7484aa6ea6e483, 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5,
 0x983e5152ee66dfab, 0xa831c66d2db43210, 0xb00327c898fb213f,
 0xbf597fc7beef0ee4, 0xc6e00bf33da88fc2, 0xd5a79147930aa725,
 0x06ca6351e003826f, 0x142929670a0e6e70, 0x27b70a8546d22ffc,
 0x2e1b21385c26c926, 0x4d2c6dfc5ac42aed, 0x53380d139d95b3df,
 0x650a73548baf63de, 0x766a0abb3c77b2a8, 0x81c2c92e47edaee6,
 0x92722c851482353b, 0xa2bfe8a14cf10364, 0xa81a664bbc423001,
 0xc24b8b70d0f89791, 0xc76c51a30654be30, 0xd192e819d6ef5218,
 0xd69906245565a910, 0xf40e35855771202a, 0x106aa07032bbd1b8,
 0x19a4c116b8d2d0c8, 0x1e376c085141ab53, 0x2748774cdf8eeb99,
 0x34b0bcb5e19b48a8, 0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb,
 0x5b9cca4f7763e373, 0x682e6ff3d6b2b8a3, 0x748f82ee5defb2fc,
 0x78a5636f43172f60, 0x84c87814a1f0ab72, 0x8cc702081a6439ec,
 0x90befffa23631e28, 0xa4506cebde82bde9, 0xbef9a3f7b2c67915,
 0xc67178f2e372532b, 0xca273eceea26619c, 0xd186b8c721c0c207,
 0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178, 0x06f067aa72176fba,
 0x0a637dc5a2c898a6, 0x113f9804bef90dae, 0x1b710b35131c471b,
 0x28db77f523047d84, 0x32caab7b40c72493, 0x3c9ebe0a15c9bebc,
 0x431d67c49c100d4c, 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a,
 0x5fcb6fab3ad6faec, 0x6c44198c4a475817,
};
void BytetoWord(BYTE* p, WORDS* Word);
void WordEx(BYTE* bufs, WORDS* Word);
void getAbit2(char* a, WORDS x, int bit);
void Round(WORDS* Word, int block, WORDS* hash);
int qwer(int a);
void WordtoByte(WORDS str, BYTE* out);
void KeyArr(BYTE* hash , BYTE* seckey, int strlength);
 
 
#endif
이 댓글을 비밀 댓글로