안녕하세요. 안드로이드 초보개발자 refeel입니다.

 

여기서 상당히 많은 정보를 얻어가면서, 이자리를 빌어 활동하시는 여러분들에게 감사의 인사를 전해드리고 싶습니다.

 

 

다름이 아니라, 액티비티간에 인텐트로 Parcelable 인스턴스를 통신시키고 있습니다.

 

메인액티비티에서 Parcelable 인터페이스를 구현해둔 DataAccess 인스턴스를 서브액티비티로 보내고,

 

서브액티비티에서는 작업쓰레드가 시간을 재고, UI쓰레드가 게임진행을 하며, 게임의 현황을 DataAccess인스턴스로 전달하는 ...

 

뭐, 이런 구조를 띄게 코딩을 하는데 ...

 

서브액티비티에서 Back버튼으로 onPause() 메서드가 호출 시, 메인액티비티에 저장된 DataAccess 인스턴스를 setResult 메서드로 보내게 하였습니다.

 

그런데, setResult의 첫번째 인자인 resultCode에 분명 RESULT_OK 상수를 전달했음에도 불구하고, 메인액티비티에서는 RESULT_CANCEL이 전달되어, 서로 통신이 되지 않고있습니다.

 

분명 서브액티비티의 onPause 메서드에서 무언가 오작동을 하고 있다는것은 느끼고 있는데 ...

 

아무리 찾아보고 어떤짓을 해봐도, 서로 통신이 되지 않으니 갑갑하기만 합니다.

 

책과 구글링으로 씨름과 씨름끝에 결국 해답을 찾지 못하여, 여기에 또 조언을 구하고자 찾아왔습니다.

 

급히 벼락치기를 해야하는 상황인지라, 개념과 기초가 많이 부실하니, 선배개발자분들께서는 이 점을 가여이 여겨, 단비같은 조언 한마디라도 해주시면 마음속 깊이 새겨 자기계발에 힘쓰도록 하겠습니다.

 

 

우선, 아래의 코드는 서브액티비티의 코드입니다.

 

  1. package project.shake;
  3. import project.shake.*;
  4. import android.app.Activity;
  5. import android.os.*;
  6. import android.app.*;
  7. import android.content.*;
  8. import android.os.*;
  9. import android.util.*;
  10. import android.view.*;
  11. import android.widget.*;
  12. import android.graphics.drawable.*;
  13. import android.hardware.*;
  15. public class GameStart extends Activity implements SensorEventListener
  16. {
  17. // 게임 논리를 구성하는 필드
  18. float forceAccel = 0; // 가속도의 벡터합(x + y + z)을 스칼라로 표현하는 변수.
  19. long lastTime;
  20. Bundle gameBundle = null; // 인텐트가 넘겨준 실제 데이터를 담는 번들. onPause, onStart 메서드에서 데이터 저장 및 복원 논리를 세워라.
  21. DataAccess gameData; // 인텐트로 넘겨받는 DataAccess 인스턴스를 담는 인스턴스변수.
  22. DataAccess tempData = null;
  24. // 가속도 변화율 구하는 변수
  25. float lastX = 0;
  26. float lastY = 0;
  27. float lastZ = 0;
  28. float x, y, z;
  30. // 가속도 센서를 가져오는 센서매니저, 센서 인스턴스, 바이브레이터 인스턴스
  31. SensorManager sm = null;
  32. Sensor accel = null;
  33. Vibrator mVib;
  35. // 디버깅용 토스트, 스트링, 기타 등등 ...
  36. String temp;
  37. TimeThread timeThread; // 시간재는 스레딩
  38. TextView mBackText; // 디버깅 텍스트뷰
  40. /** Called when the activity is first created. */
  42. public void onAccuracyChanged(Sensor arg0, int arg1) { }
  44. // 실험용 쓰레드가 초단위로 메세지를 보냄. ^ㅅ^
  45. Handler timeHandler = new Handler() {
  46. public void handleMessage(Message msg)
  47. {
  48. mBackText.setText("경과시간 : " + (msg.arg1+1)); // 텍스트뷰 쳐묵쳐묵
  50. Log.e("시간 체크(핸들러 메세지)", ""+msg.arg1);
  52. if(msg.arg1 >= 30) // 제한시간이 된다면,
  53. {
  54. Intent intent = new Intent(GameStart.this, GameResult.class); // 게임 리절트로 넘어간다.
  55. intent.putExtra("GameData", gameData);
  56. startActivity(intent);
  57. finish();
  58. }
  59. }
  60. };
  62. @Override
  63. public void onCreate(Bundle savedInstanceState)
  64. {
  65. Log.e("GameStart.java/onCreate 호출", "ㅇㅋ");
  67. super.onCreate(savedInstanceState);
  69. Log.e("gameData 인스턴스 생성", "ㅇㅋ");
  70. // 메인액티비티에서 넘겨온 Parcelable 인스턴스를 저장.
  71. gameBundle = getIntent().getExtras();
  72. gameData = gameBundle.getParcelable("GameData");
  73. //tempData = gameData; // 주석처리해도 상관없지 싶다.
  76. timeThread = new TimeThread(timeHandler);
  77. timeThread.setDaemon(true);
  78. timeThread.start();
  80. getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON); // 앱실행중 자동꺼짐 방지
  81. sm = (SensorManager)getSystemService(Context.SENSOR_SERVICE);
  82. accel = sm.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
  83. setContentView(R.layout.gamestart);
  85. mVib = (Vibrator)getSystemService(Context.VIBRATOR_SERVICE); // 바이브레이터 인스턴스 끌어씀
  87. mBackText = (TextView)findViewById(R.string.count);
  88. }
  90. public void onSaveInstanceState(Bundle outState)
  91. {
  92. Log.e("onSaveInstanceState()로 현재 인스턴스 저장", "ㅇㅋ");
  93. gameData.threadDead = DataAccess.RUNNABLE;
  94. outState.putParcelable("saved", gameData);
  95. }
  97. // 차라리 여기에, GameMain으로 현재 Parcelable 인스턴스를 메인에게 리턴해줄까 ;; ... GameMain에서는 리턴받은 인스턴스를 이쪽으로 넘기면 되는거고. 그럼 깔끔하냐.
  98. public void onDestroy()
  99. {
  100. super.onDestroy();
  101. Log.e("GameStart.java/onDestroy() 호출", "ㅇㅋ");
  102. }
  104. public void onStart()
  105. {
  106. super.onStart();
  107. Log.e("GameStart.java/onStart() 호출", "ㅇㅋ");
  108. gameData.threadDead = DataAccess.RUNNABLE;
  109. if (accel != null)
  110. sm.registerListener(this, accel, SensorManager.SENSOR_DELAY_GAME);
  111. }
  113. public void onResume()
  114. {
  115. super.onResume();
  116. gameData.threadDead = DataAccess.RUNNABLE;
  117. Log.e("GameStart.java/onResume() 호출", "ㅇㅋ");
  118. }
  120. // 여기서 나는 계속 RESULT_OK를 보내지만, 게임메인.java에서는 RESULT_CALCEL을 받게되네 -_- ...
  121. public void onPause()
  122. {
  123. super.onPause();
  124. if(sm != null) // Pause상태에서 센서를 해제.
  125. sm.unregisterListener(this);
  126. gameData.threadDead = DataAccess.DEAD;
  127. Log.e("GameStart.java/onPause() 호출", "ㅇㅋ");
  128. Log.e("GameStart.java/onPause() 상태에서 저장된 시간 : ", ""+gameData.currentTime);
  129. Intent intent = new Intent();
  130. intent.putExtra("GameSaved", gameData);
  131. Log.e("게임 저장 후 데이터 : ", ""+gameData.currentTime);
  132. Log.e("게임 저장 후 데이터 : ", ""+gameData.forceSumForScore);
  133. Log.e("게임 저장 후 데이터 : ", ""+gameData.limitGameTime);
  134. Log.e("게임 저장 후 데이터 : ", ""+gameData.shakeCount);
  135. Log.e("게임 저장 후 데이터 : ", ""+gameData.threadDead);
  136. setResult(RESULT_OK, intent);
  137. finish();
  138. }
  140. // 가속도센서를 감지하여, 게임 논리를 진행하는 코드
  141. ...
  143. //타이머 쓰레드 -> 이너 쓰레드로 교체;
  144. class TimeThread extends Thread
  145. {
  146. int currentGameTimeThread; // 실제 카운팅되는 상대시간. 초단위로 계산되며,
  147. // if(currentGameTime == limitTime) 게임끗();
  148. Handler timeHandler; // 현재시간을 초단위로 UI쓰레드에게 넘김.
  150. TimeThread(Handler handler)
  151. {
  152. timeHandler = handler;
  153. currentGameTimeThread = gameData.currentTime;
  154. }
  156. public void run()
  157. {
  158. //currentGameTime = gameData.currentTime;
  159. Log.e("run() 호출", "ㅇㅋ");
  160. while(true)
  161. {
  162. Message msg = Message.obtain(timeHandler, 0, currentGameTimeThread, 0);
  163. timeHandler.sendMessage(msg);
  164. currentGameTimeThread++;
  165. gameData.currentTime = currentGameTimeThread;
  167. //Log.e("run() 내부 while 루프 진입", "ㅇㅋ");
  169. if(currentGameTimeThread >= gameData.limitGameTime || gameData.threadDead == DataAccess.DEAD)
  170. {
  171. //Log.e("run() 내부 while 루프 진입", "ㅇㅋ");
  172. //Log.e("currentGameTime : ", ""+currentGameTime);
  173. //Log.e("첫번째 boolean : ", ""+(currentGameTime >= gameData.limitGameTime));
  174. //Log.e("두번째 boolean : ", ""+(gameData.threadDead == DataAccess.DEAD));
  175. gameData.currentTime = currentGameTimeThread-1; // 현재까지 카운트한 시간을 저장한다.
  176. break; // 여기다가 || 게임중단시 종료를 시켜줘야겠구만.
  177. }
  179. try
  180. {
  181. Thread.sleep(1000);
  182. }
  184. {
  185. e.printStackTrace();
  186. }
  187. }
  189. Log.e("run() 메서드 반환", "ㅇㅋ");
  190. }
  191. }
  192. }

 

아래의 코드는 메인액티비티의 코드입니다.

 

  1. package project.shake;
  3. import project.shake.*;
  4. import android.app.Activity;
  5. import android.os.*;
  6. import android.app.*;
  7. import android.content.*;
  8. import android.os.*;
  9. import android.util.*;
  10. import android.view.*;
  11. import android.widget.*;
  12. import android.graphics.drawable.*;
  13. import android.hardware.*;
  15. public class GameMain extends Activity {
  16. /** Called when the activity is first created. */
  17. DataAccess gameData;
  18. public static final int GAMESTART = 0;
  19. public static final int GAMEOPTION = 1;
  21. @Override
  22. public void onCreate(Bundle savedInstanceState) {
  23. // 스플래시 화면 띄우기.
  24. startActivity(new Intent(this, GameMainLoading.class));
  25. // public DataAccess(int vive, int limit, int shake, float sumScore, int threadLife, int cTime)
  26. gameData = new DataAccess(DataAccess.VIVE_ON, DataAccess.DEFAULT_TIME, 0, 0.0f, DataAccess.RUNNABLE, 0); // 전체 데이터를 관리하는 인스턴스 생성!
  27. // 앞으로 이놈은 여러 액티비티를 타고 이동하며 게임을 컨트롤한다.
  28. super.onCreate(savedInstanceState);
  29. getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON); // 앱실행중 자동꺼짐 방지
  30. setContentView(R.layout.gamemain);
  32. Log.e("생성후 진동 토글 : ", ""+gameData.toggleVive);
  33. Log.e("생성후 게임 시간 : ", ""+gameData.limitGameTime);
  34. Log.e("생성후 흔든 횟수 : ", ""+gameData.shakeCount);
  35. Log.e("생성후 벡터 합계 : ", ""+gameData.forceSumForScore);
  36. Log.e("생성후 진동 토글 : ", ""+gameData.toggleVive);
  37. Log.e("생성후 쓰레드 삶 : ", ""+gameData.threadDead);
  38. }
  40. public void mOnClick(View v)
  41. {
  42. Intent intent;
  43. switch(v.getId())
  44. {
  45. case R.id.gamestart : // 게임시작 버튼
  46. intent = new Intent(this, GameStart.class);
  47. intent.putExtra("GameData", gameData); // 인텐트 통신. (게임에 필요한 실제 논리를 전달)
  48. startActivityForResult(intent, GAMESTART);
  49. break;
  51. case R.id.gamehelp : // 게임방법 버튼
  52. intent = new Intent(this, GameHelp.class);
  53. startActivity(intent);
  54. break;
  56. case R.id.gameoption : // 게임옵션 버튼
  57. intent = new Intent(this, GameOption.class);
  58. intent.putExtra("GameOption", gameData); // 인텐트 통신. (옵션에서 시간 및 진동여부를 토글)
  59. startActivityForResult(intent, GAMEOPTION);
  60. break;
  61. }
  62. }
  64. protected void onActivityResult(int requestCode, int resultCode, Intent data)
  65. {
  66. switch(requestCode)
  67. {
  68. case GAMESTART :
  69. Log.e("GameMain.java/case GAMESTART : 진입", "ㅇㅋ");
  70. if(resultCode == RESULT_OK)
  71. {
  72. Log.e("GameMain.java/GAMESTART if문 진입", "ㅇㅋ");
  73. Bundle dataBackup = data.getParcelableExtra("GameSaved"); // GameData.java에서 수정된 액티비티가 넘어와서 gameData에 저장됨.
  74. gameData = dataBackup.getParcelable("GameData");
  76. Log.e("GameMain.java/진동 토글 : ", ""+gameData.toggleVive);
  77. Log.e("GameMain.java/게임 시간 : ", ""+gameData.limitGameTime);
  78. Log.e("GameMain.java/흔든 횟수 : ", ""+gameData.shakeCount);
  79. Log.e("GameMain.java/벡터 합계 : ", ""+gameData.forceSumForScore);
  80. Log.e("GameMain.java/진동 토글 : ", ""+gameData.toggleVive);
  81. Log.e("GameMain.java/저장 시간 : ", ""+gameData.currentTime);
  82. }
  83. else
  84. Log.e("전달된 값 : ", ""+RESULT_CANCELED);
  85. break;
  86. case GAMEOPTION :
  87. // 코드 처리할것.
  88. break;
  89. }
  90. }
  92. public void onDestroy()
  93. {
  94. super.onDestroy();
  95. Log.e("GameMain/onDestroy() 호출", "ㅇㅋ");
  96. }
  98. public void onPause()
  99. {
  100. super.onPause();
  101. Log.e("GameMain/onPause() 호출", "ㅇㅋ");
  102. }
  103. }

 

아래의 코드는 DataAccess의 클래스바디 입니다.

 

  1. package project.shake;
  3. import android.os.*;
  5. // 시간나면 클래스들 전체의 은닉, 캡슐화를 추진할것.
  6. // 게임의 점수, 옵션셋팅, 기타등등 잡다한것 넣어둔 데이터 클래스. 일단 전부 퍼블릭. -_-.
  7. public class DataAccess implements Parcelable, Cloneable
  8. {
  9. // 옵션에서 셋팅.
  10. public int toggleVive; // 1 : on, 0 : off
  11. public int limitGameTime;
  13. // 상수.
  14. public static final int GAME_RUN = 0x76545400; // 게임 계속
  15. public static final int GAME_END = 0x76545401; // 게임 끝 (시간이 다되었음.)
  16. public static final int GAME_PAUSE = 0x76545402; // 게임 일시중지.
  17. public static final int VIVE_ON = 1; // 진동 on
  18. public static final int VIVE_OFF = 0; // 진동 off
  19. public static final int DEAD = 0; // 쓰레드 죽음
  20. public static final int RUNNABLE = 1; // 쓰레드 살음(살리거나.)
  21. public static final int DEFAULT_TIME = 30; // 시간 : 디폴트로 30초
  23. // 흔든 횟수 및 점수 스코어 계산.
  24. public int shakeCount; // 흔든 횟수. 타 클래스에서도 인스턴스 없이 참조하도록 static
  25. public float forceSumForScore; // forceAccel 의 누적합을 구함.
  26. // forceSumForScore += forceAccel;
  27. // 쓰레드 컨트롤(게임중 홈버튼/백버튼 누르면 GameStart.java에서 onPause가 호출되므로, 이 값을 적절히 토글시켜서 쓰레드를 죽여야한다.
  28. // public boolean toggleGamePause = false;
  29. public int threadDead;
  30. public int currentTime;
  32. // GameMain에서 생성한 인스턴스는 초기화되어서 온갖 액티비티에서 다 참조하지롱. -_-
  33. // 은닉 캡슐화따윈 캡슐에 개밥뿌려먹어.
  34. public DataAccess(int vive, int limit, int shake, float sumScore, int threadLife, int cTime)
  35. {
  36. // 최초 디폴트 옵션. 물론, 환경설정에서 바꿀 수 있는데 이게 개나소나 참조할 수 있으니 문제지. -_-...
  37. toggleVive = vive;
  38. limitGameTime = limit;
  40. // 최초 흔든 횟수랑 점수 스코어는 0회/0점.
  41. shakeCount = shake;
  42. forceSumForScore = sumScore;
  44. threadDead = threadLife;
  45. currentTime = cTime;
  46. }
  48. public DataAccess(Parcel src)
  49. {
  50. toggleVive = src.readInt();
  51. limitGameTime = src.readInt();
  53. shakeCount = src.readInt();
  54. forceSumForScore = src.readFloat();
  56. threadDead = src.readInt();
  57. currentTime = src.readInt();
  58. }
  60. public void initZeroScore() // 게임종료후, 흔든횟수랑 점수를 0으로 초기화한다. 이건 반드시 게임 리절트 후, 호출시켜라.
  61. {
  62. shakeCount = 0;
  63. forceSumForScore = 0.0f;
  64. }
  66. public void scoreCalculation() // 구한 가속도의 합을 토대로 0~100 사이의 점수로 계산지을 것!
  67. {
  68. // 구현하세요. 근데 0~100점내로 어떻게 합산하지... =_=...
  69. }
  72. public int describeContents() {
  73. // TODO Auto-generated method stub
  74. return 0;
  75. }
  77. // 파슬 인스턴스에 데이터를 출력시킴.
  78. public void writeToParcel(Parcel desc, int arg1)
  79. {
  80. // TODO Auto-generated method stub
  81. desc.writeInt(toggleVive);
  82. desc.writeInt(limitGameTime);
  84. desc.writeInt(shakeCount);
  85. desc.writeFloat(forceSumForScore);
  87. desc.writeInt(threadDead);
  88. desc.writeInt(currentTime);
  89. }
  91. public void readFromParcel(Parcel in)
  92. {
  93. toggleVive = in.readInt();
  94. limitGameTime = in.readInt();
  96. shakeCount = in.readInt();
  97. forceSumForScore = in.readFloat();
  99. threadDead = in.readInt();
  100. currentTime = in.readInt();
  101. }
  105. public Object clone()
  106. {
  107. // 깊은복사를 위한 클론메서드. 일단 나중에 구현해보자.
  108. return (DataAccess)this;
  109. }
  111. public static final Parcelable.Creator<DataAccess> CREATOR = new Parcelable.Creator<DataAccess>() {
  112. public DataAccess createFromParcel(Parcel in) {
  114. return new DataAccess(in);
  115. }
  117. public DataAccess[] newArray(int size) {
  118. return new DataAccess[size];
  119. }
  120. };
  121. }

 

미리 올라올 조언에 감사드립니다.

이 게시물을