아이폰어플개발정보2010. 8. 23. 09:36
[펌] iPhone용 Open Source 모음
공부를 하다 보면 책에 나오는 간단 간단한 소스가 아닌 전체 프로그램에 대한 소스를 보고 싶어질 때가 있습니다.
그래서 자료를 찾아 보았습니다. 참고하세요.
 
<여러 UI 모음: photo viewer, etc>
http://github.com/facebook/three20 (초기에는 facebook 어플이었으나 현재는 여러 UI 모음으로 바뀜 )
http://code.google.com/p/route-me/

<E-mail>
 
 
<달력>
http://ved-dimensions.blogspot.com/2009/04/iphone-development-creating-native_09.html

<sqlite>

<계산기>

<트위터 클라이언트>
http://github.com/blog/329-natsuliphone-iphone-twitter-client
http://github.com/facebook/facebook-iphone-sdk

http://www.joystiq.com/2009/03/24/carmack-releases-open-source-wolfenstein-for-iphone/

http://code.google.com/p/google-toolbox-for-mac/


http://kldp.net/projects/taekbae/src

http://code.google.com/p/simple-iphone-image-processing/


http://www.chaosinmotion.com/flowcover.m (매가박스 어플에서 참고함)


출처 : http://blog.naver.com/PostView.nhn?blogId=baek2187&logNo=150086976224
Posted by 오늘마감

댓글을 달아 주세요

아이폰어플개발정보2010. 8. 22. 19:58
[펌] iPhone 어플리케이션 아이콘 설정
맥과는 달리 아이폰에서는 아이콘 파일(*.icns)을 사용하지 않고, 57X57 사이즈의 PNG 파일 포맷을 사용하는 것 같습니다.






재미있는 것은 좌측이 원본 아이콘 이미지이고 우측이 아이폰의 홈스크린에서 보여지는 모습입니다. 시스템에서 자동으로 아이콘의 모서리를 둥글게 보여주고 명함 효과를 주기 때문에 이미지에서 별도의 작업이 필요 없습니다.


만약 이미지에 배경이 없고 투명색으로 처리되었을 경우에는 좌측과 같이 검정색 배경의 아이폰 아이콘의 형식으로 출력이 됩니다.




* 아이콘 파일 등록
아이콘 파일은 메뉴의'Project/Add to Project...'나 Groups & Files에서 해당 디렉토리를 우클릭 한 후에 아래와'같이 Add/Exsiting Files...'를 클릭하여 해당 파일을 선택하시면 됩니다.



* 아이콘 파일 지정
사용자가 지정하지 않으면 실행파일 번들내의 Icon.png를 기본 아이콘 파일로 인식합니다. 별도로 아이콘 파일을 지정할 경우에는Info.plist 또는 아래와 같이 타겟의 Info Properties의 'Icon File:' 항목에서 png 확장자를제외한 파일명을 입력합니다. 



출처 : http://blog.naver.com/PostView.nhn?blogId=baek2187&logNo=150055162184
Posted by 오늘마감

댓글을 달아 주세요

아이폰어플개발정보2010. 8. 22. 19:58
[펌] 아이폰 어플리케이션 개발 준비부터 등록까지 (초요약버전)
아이폰 어플리케이션 개발 준비부터 등록까지 (초요약버전)
 
 
1. 개발 준비
   - 개발을 할 수 있는 맥 컴퓨터 준비 (Mac OS X 설치되어 있어야 함)
   - 실제 개발한 프로그램을 올려서 테스트 해볼 수 있는 아이팟/아이폰 준비

2. 애플 개발자 등록
   - 회사의 경우 사업자 등록증 등을 팩스로 보내고, 확인 전화를 받아서 확인을 한 후 등록 가능
      (약 10만원의 등록비용이 드니 미리 준비)

3. 개발환경 구축
   - Xcode, SDK 다운로드 및 설치 (모두 무료)

4. 프로그램 개발
   - 일단은 아이폰 시뮬레이터로 테스트 가능 (5번을 동시에 진행 가능)

5. 디바이스에 올려서 테스트
   - iPhone Developer Program Portal에서 아래 과정을 진행해줘야 함.
      (각 항목마다 How To 페이지가 있으니 잘 보고 따라하면 됨)
      a. 팀원으로 등록 (개인인 경우 패스)
      b. Development Certificate 받아서 설치
      c. 기기 등록 (100대까지 기기 등록을 할 수 있음)
      d. App ID 생성
      e. Development Provisioning Profile 생성 후 다운로드, 설치
   - 빌드 할 때, Build Info 에서 Provisioning Profile 선택 및 Target을 Device로 설정해서 Build
   => 실제 기기에서 돌아가게 하면서 디버깅 할 수 있음

6. 앱스토어에 등록할 배포용 빌드하기
   - iPhone Developer Program Portal에서 아래 과정을 진행해줘야 함.
      a. 위 5.b에서 한것처럼 Distribution Certificate 받아서 설치
      b. 위 5.e에서 한것처럼 Distribution Provisioning Profile을 생성 후 다운로드해서 설치
      c. Distribution 용 Build Target을 만들고, 
          Build Info에서 설치한 Provisioning Profile을 선택하고, 프로그램 버전 정보, 이름 등 지정 후 빌드.

7. 앱스토어에 등록하기
   - iPhone Dev Center > iTunes Connect > Manage Your Applications
      에 들어가서 Add New Application.
      등록할 때 아래 것들이 준비되어 있어야 함.
      a. 6번에서 만든 배포용 빌드한 바이너리 -> zip 으로 압축한 zip 파일
      b. 512x512 짜리 큰 아이콘 이미지
      c. 스크린샷 (Status Bar를 없앤 320x460 사이즈의 스크린샷 파일)
      d. 프로그램을 설명하는 글
      => 이것들이 준비되어 있으면,  요구하는 정보들을 잘 입력해주면 됨.

8. 등록 심사/대기
    - 7번 과정으로 추가를 하면 애플쪽에서 심사를 한 후 등록 또는 거절 될 수 있음.
       심사 과정은 대략 1주~3주까지도 걸리는 듯함. 
       아주 간단한것이 아니고는 2주 정도 예상하고 있으면 될듯함.
       * 혹 거절되면 다시 수정을 하던해서 다시 등록을 하고, 또 기다려야 함.

9. Bank Info, Tax Info 등록
    - 유료로 파는 것을 등록한다면 이 과정을 처리해줘야 함. (어플 등록 전 해도 되고 등록 후에 해도 됨)
       : iPhone Dev Center > iTunes Connect > Contracts, Tax & Banking Information
         에 들어가서 정보들을 입력

10. 등록 완료
    - 등록완료되면 메일이 오고, 이제 홍보 시작!
       Promotional Codes를 받아서, 사람들에게 나눠줘서 무료로 받아보게 할 수 있음(유료어플의 경우)
       어플리케이션별로 50개씩 받아서 뿌릴 수 있음 (대신, iTunes 미국 AppStore 계정이 있어야 함;;;)
       (iPhone Dev Center > iTunes Connect > Request Promotional Codes)       

11. 내 어플은 몇 개나 다운되었나?
    - iPhone Dev Center > iTunes Connect > Sales/Trend Reports
       에 들어가면, 일/주/월 단위로 어느 지역에서 얼만큼 다운되었는지 볼 수 있음.


위 글은 http://blog.xiles.net 에서도 보실 수 있습니다.
(블로그에 몇 개의 글이 더 있고, 앞으로 올리는 글들도 공유할 수 있도록 하겠습니다.)
 


출처 : http://blog.naver.com/PostView.nhn?blogId=baek2187&logNo=150079417804
Posted by 오늘마감

댓글을 달아 주세요

아이폰어플개발정보2010. 6. 21. 18:31
[펌] iPhone Gaming Framework: Stage1 Turorial

출처:http://eguru.co.kr/775

Buckle in guys, this is going to be a rather large tutorial. The goal for this tutorial is to get a basic screen management system up and running, ready to start writing game code. I would like to start off by saying the following: This is not the only way to get a project up and running! There are many many many ways of solving problems in the programming world. Some people might prefer to use Cocos2D for the iPhone, while others might prefer to roll their own engine from scratch. I did this more as a learning process for myself, and now that I’ve learned what I could, i thought I should share the knowledge to everyone else who is struggling with the problems that I’ve solved.

Also, keep in mind that this screen management system is basically a port of the GameStateManagement demo from the XNA sample ( http://creators.xna.com/ ) from C# to Objective-C with some modifications. Anyone currently using XNA should have a fairly easy time porting this over, as a lot of the code should be recognizable to you.

So, now that I’ve got that out of the way, lets begin! Your first step is going to head over to Jeff’s blog iPhoneDevelopment and pick up the Updated OpenGL Xcode Project Template.

Next step, is to follow his directions and install it! Once you have it installed, load a new project using his template. You will find that a few things are different, and a whole lot is added. Open up the GLView.m in the classes subdirectory, and add the following four methods:

  1. - (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event   
  2. {   
  3.     [controller touchesBegan:touches withEvent:event InView:self  WithTimer:animationTimer];   
  4. }   
  5. - (void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event   
  6. {   
  7.     [controller touchesMoved:touches withEvent:event InView:self  WithTimer:animationTimer];   
  8. }   
  9. - (void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event   
  10. {   
  11.     [controller touchesEnded:touches withEvent:event InView:self  WithTimer:animationTimer];   
  12. }   
  13. - (void)touchesCancelled:(NSSet *)touches withEvent:(UIEvent *)event   
  14. {   
  15.     [controller touchesCancelled:touches withEvent:event InView:self  WithTimer:animationTimer];   
  16. }  
  17. What this is going to do, is when your iPod touch or iPhone is touched, a message is sent to the GLView. We are going to capture that message, and send it to the GLViewController. Okay, got that done? GREAT! Now comes the fun stuff.

    Open up your GLViewController.h file. You are going to be putting in quite a bit of code, and i’ll explain everything when we do the .m file, so for right now just adjust your .h file to look like the following. You’ll see the .m file is HEAVILY commented to show what everything is and what it does, and i’ll make some additional notes here as well… so here is the GLViewController.h file.

    1. //
    2. //  The View Controller is a service which mananges one or more GameScreen
    3. //  instances. It maintains a stack of screens, calls their Update and Draw
    4. //  methods at the appropriate times, and automatically routes the input to
    5. //  the topmost active screen.
    6. //
    7. //  Created by XNA Development Team ( http://creators.xna.com/ ) as a
    8. //  ScreenManager.cs GameComponent.
    9. //
    10. //  Adapted for iPhone Game Development by Craig Giles on 1/1/09.
    11. //
    12. //
    13. //  Import statements
    14. //
    15. #import <UIKit/UIKit.h>
    16. #import <OpenGLES/EAGL.h>
    17. #import <OpenGLES/ES1/gl.h>
    18. #import <OpenGLES/ES1/glext.h>
    19. #import "Texture2D.h"
    20. #import "InputManager.h"
    21. #import "GameScreen.h"
    22. #import "TitleScreen.h"
    23. @class GLView;   
    24. @interface GLViewController : UIViewController   
    25. {   
    26.     NSMutableArray *screens;   
    27.     NSMutableArray *screensToUpdate;   
    28.     InputManager *input;   
    29.     Texture2D *blankTexture;   
    30. bool isInitialized;   
    31. bool traceEnabled;     
    32.     UIView *gameView;   
    33.     CGRect viewport;   
    34. }   
    35. //
    36. //  Properties
    37. //
    38. @property (nonatomic, retain) NSMutableArray *screens;   
    39. @property (nonatomic, retain) NSMutableArray *screensToUpdate;   
    40. @property (nonatomic, retain) InputManager *input;   
    41. @property (nonatomic, retain) Texture2D *blankTexture;   
    42. @property (nonatomic, readwrite) bool isInitialized;   
    43. @property (nonatomic, readwrite) bool traceEnabled;   
    44. @property (nonatomic, retain) UIView *gameView;   
    45. @property (nonatomic, readwrite) CGRect viewport;   
    46. //
    47. //  Methods
    48. //
    49. - (void) setupView:(GLView*)view;   
    50. - (void) loadContent;   
    51. - (void) addScreen:(GameScreen *)screen;   
    52. - (void) removeScreen:(GameScreen *)screen;   
    53. - (void) releaseScreen:(GameScreen *)screen;   
    54. - (void) updateView:(GLView *)view WithTime:(float)deltaTime;   
    55. - (void) drawView:(GLView *)view WithTime:(float)deltaTime;   
    56. - (void) traceScreens;   
    57. - (void) fadeBackBufferToBlack:(double)alpha;   
    58. //
    59. //  Touches events
    60. //
    61. - (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event InView:(UIView *)touchView WithTimer:(NSTimer *)timer;   
    62. - (void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event InView:(UIView *)touchView WithTimer:(NSTimer *)timer;   
    63. - (void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event InView:(UIView *)touchView WithTimer:(NSTimer *)timer;   
    64. - (void)touchesCancelled:(NSSet *)touches withEvent:(UIEvent *)event InView:(UIView *)touchView WithTimer:(NSTimer *)timer;   
    65. @end  
    66. Its a good idea to look through the .h file to see what you can do with the screen manager. Obviously you can do the touch events (remember we connected those from the GLView?) but also, looking at the methods you will be able to add and remove screens from the screen manager, update and draw, fade back buffer to black, and a few other things. Lets see how it all works!

      1. //
      2. //  The View Controller is a service which mananges one or more GameScreen
      3. //  instances. It maintains a stack of screens, calls their Update and Draw
      4. //  methods at the appropriate times, and automatically routes the input to
      5. //  the topmost active screen.
      6. //
      7. //  Created by XNA Development Team ( http://creators.xna.com/ ) as a
      8. //  ScreenManager.cs GameComponent.
      9. //
      10. //  Adapted for iPhone Game Development by Craig Giles on 1/1/09.
      11. //
      12. //
      13. //  Import commands from Jeff's template
      14. //
      15. #import "GLViewController.h"
      16. #import "GLView.h"
      17. #import "OpenGLCommon.h"
      18. #import "ConstantsAndMacros.h"
      19. //
      20. //  This indicates weather or not the game will be played in
      21. //  landscape or portrait mode. While in landscape mode, the
      22. //  screen will be rotated, but also the input will be off.
      23. //  Touch coordinates for the screen will have to be converted
      24. //  before it reaches the input manager class.
      25. //
      26. constbool LANDSCAPE_MODE = NO;   
      27. //
      28. //  The time it takes for a game screen to transition
      29. //  These can be over written in the game screen init.
      30. //  If there is no values in the game screen itself, these
      31. //  will be used as the default values.
      32. //
      33. constfloat TRANSITION_ON_TIME = .70f;   
      34. constfloat TRANSITION_OFF_TIME = .20f;   
      35. //
      36. //  Implementation of the Screen Manager class
      37. //
      38. @implementation GLViewController   
      39. //
      40. //  Getters / Setters
      41. //
      42. @synthesize screens;   
      43. @synthesize screensToUpdate;   
      44. @synthesize input;   
      45. @synthesize blankTexture;   
      46. @synthesize isInitialized;   
      47. @synthesize traceEnabled;   
      48. @synthesize gameView;   
      49. @synthesize viewport;   
      50. //
      51. //  Setup View handles setting up OpenGL's Projection Matrix and
      52. //  enables all states needed for rendering the game to screen.
      53. //
      54. -(void)setupView:(GLView*)view   
      55. {   
      56. //  Set the view to the gameView
      57.     gameView = view;   
      58. //  Modify the Projection matrix
      59.     glMatrixMode(GL_PROJECTION);   
      60.     glLoadIdentity();   
      61. //
      62. //  Orthof projection is used for 2d games. This sets the coordinates to
      63. //  (0, 0) at the top left corner of the screen, and as you move downward
      64. //  your y value will increase. As you move to the right, your x value will
      65. //  increase.
      66. //  (left, right, bottom, top, near, far)
      67. //
      68. //  If the game is going to be played in landscape mode, enable
      69. //  it via the bool switch at the top of the GLViewController.m file.
      70. if ( LANDSCAPE_MODE )   
      71.     {   
      72.         viewport = CGRectMake(0, 0, 480, 320);   
      73.         glViewport(0, 0, viewport.size.height, viewport.size.width);   
      74.         glRotatef(-90, 0, 0, 1);   
      75.         glOrthof(0, viewport.size.width, viewport.size.height, 0, -10.0, 10.0);     
      76.     }   
      77. else//  Game is to be played in portrait
      78.     {   
      79.         viewport = CGRectMake(0, 0, 320, 480);   
      80.         glViewport(0, 0, viewport.size.width, viewport.size.height);   
      81.         glOrthof(0.0, viewport.size.width, viewport.size.height, 0.0, -1.0, 1.0);      
      82.     }   
      83. //
      84. //  Setup Model view matrix
      85. //  Load graphics settings
      86. //
      87.     glMatrixMode(GL_MODELVIEW);   
      88.     glDisable(GL_DEPTH_TEST);   
      89.     glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);   
      90.     glEnable(GL_BLEND);    
      91. //  needed to draw textures using Texture2D
      92.     glEnable(GL_TEXTURE_2D);   
      93.     glEnableClientState(GL_TEXTURE_COORD_ARRAY);   
      94.     glEnableClientState(GL_VERTEX_ARRAY);   
      95. //  enables alpha for transparent textures
      96. //  I forget where I got these commands, iDevGames.net I think
      97.     glAlphaFunc(GL_GREATER, 0.1f);   
      98.     glEnable(GL_ALPHA_TEST);   
      99. //
      100. //  Setup clear color (cornflower blue'ish)
      101. //  Call me crazy, but I got so used to this color developing
      102. //  for XNA. This is a little nod to the Microsoft Development
      103. //  Team :)
      104. //
      105.     glLoadIdentity();   
      106.     glClearColor(.39f, 0.58f, 0.920f, 1.0f);    
      107. //
      108. //  Call the view controllers loadContent method
      109. //
      110.     [self loadContent];   
      111. }   
      112. //
      113. //  Loads all content needed to run the screen manager. This is seperated
      114. //  from the setupView method in order to seperate what is needed from OpenGL
      115. //  to setup the screen, and what is needed from the screen manager to set
      116. //  up the game structure.
      117. //
      118. - (void)loadContent   
      119. {   
      120. //
      121. //  Allocate memory for your arrays to hold the Screens "stacks."
      122. //  All game screens will be housed in this array for easy manipulation.
      123. //
      124.     screens = [[NSMutableArray alloc] init];   
      125.     screensToUpdate = [[NSMutableArray alloc] init];   
      126. //
      127. //  Allocate memory for the input manager and the blankTexture used
      128. //  to fade the screen in / out.
      129. //
      130.     input = [[InputManager alloc] init];   
      131.     input.isLandscape = LANDSCAPE_MODE;   
      132.     blankTexture = [[Texture2D alloc] initWithImage:[UIImage imageNamed:@"blankTexture.png"]];   
      133. for (GameScreen *screen in screens)   
      134.         [screen loadContent];   
      135. //
      136. //  Once we are initialized, set the bool values to appropriate values.
      137. //
      138.     isInitialized = YES;   
      139.     traceEnabled = NO;   
      140. //
      141. //  Adds a title screen to the game stack. This will be taken out
      142. //  later, and right now is only used for debugging purposes. It
      143. //  will be replaced with your splash screen or game introduction
      144. //  screen.
      145. //
      146.     TitleScreen *newScreen = [[TitleScreen alloc] init];   
      147.     [self addScreen:newScreen];   
      148.     [newScreen release];   
      149. }   
      150. //
      151. //  When the view controller exits, we will need to clean up any memory used.
      152. //
      153. - (void)dealloc   
      154. {   
      155. //
      156. //  setup a delete screens array and add all of the current game screens
      157. //  to this array. We will then cycle through all game screens, unloading
      158. //  their content, and releasing them from the view controller. After all
      159. //  is said and done, we will then remove the deleteScreens array, and
      160. //  continue on releasing any other memory allocated for the view controller.
      161. //
      162.     NSMutableArray *deleteScreens = [[NSMutableArray alloc] initWithArray:screens];   
      163. for (GameScreen *screen in deleteScreens)   
      164.     {   
      165.         [self removeScreen:screen];   
      166.         [self releaseScreen:screen];   
      167.     }   
      168.     [deleteScreens release];   
      169.     [screens release];   
      170.     [screensToUpdate release];   
      171.     [input release];   
      172.     [blankTexture release];   
      173.     [super dealloc];   
      174. }   
      175. //
      176. //  If the game is going over memory, this method will be called by the device
      177. //  warning that we are running low on memory and should release any un needed
      178. //  items.
      179. //
      180. - (void)didReceiveMemoryWarning   
      181. {   
      182. //  <<TODO: Unload any un-needed game content here>>
      183.     [super didReceiveMemoryWarning];   
      184. }   
      185. //
      186. //  Add a screen to the view controller
      187. //
      188. - (void) addScreen:(GameScreen *)screen   
      189. {   
      190. //
      191. //  When adding a screen to the view controller, we will be
      192. //  setting some default values for the screen, and then call
      193. //  the screens "loadContent" method. Once everything is loaded,
      194. //  the view controller will retain the screen and add it to the
      195. //  screens array.
      196. //
      197.     screen.controller = self;   
      198.     screen.viewport = self.viewport;   
      199.     screen.transitionOnTime = TRANSITION_ON_TIME;   
      200.     screen.transitionOffTime = TRANSITION_OFF_TIME;   
      201.     screen.currentScreenState = TransitionOn;   
      202.     screen.transitionPosition = 1;   
      203.     [screen loadContent];   
      204.     [screen retain];   
      205.     [screens addObject:screen];   
      206. }   
      207. //
      208. //  Unload all game content from the screen. This in turn
      209. //  sets a flag within the screen itself, that the content has
      210. //  been unloaded, and in the controllers Update method, all game
      211. //  screens that have been unloaded will be released from memory.
      212. //
      213. - (void) removeScreen:(GameScreen *)screen   
      214. {   
      215. //unload any content it has stored
      216.     [screen unloadContent];   
      217. }   
      218. //
      219. //  Release all game screens from memory, that have had their content
      220. //  unloaded. This will release all screens themselves, as well as remove
      221. //  them from the screens arrays.
      222. //
      223. - (void) releaseScreen:(GameScreen *)screen   
      224. {   
      225. //  remove the screen from all screen arrays
      226.     [screens removeObject:screen];   
      227.     [screensToUpdate removeObject:screen];   
      228. //  deallocate any memory used for the screen
      229.     [screen release];   
      230. }   
      231. //
      232. //  Update every screen in the screens stack, keeping track
      233. //  of which screens are covered and which are fully active.
      234. //  if a screen is fully active and "on top" of the stack, it
      235. //  should receive any input.
      236. //
      237. - (void) updateView:(GLView *)view WithTime:(float)deltaTime   
      238. {   
      239. //  Read the touch input
      240.     [input update:deltaTime];   
      241. //  make a copy of hte master screen list, to avoid confusion if
      242. //  the process of updating one screens adds or removes others.
      243.     [screensToUpdate removeAllObjects];   
      244. for(GameScreen *screen in screens)   
      245.         [screensToUpdate addObject:screen];   
      246. bool otherScreenHasFocus = NO;   
      247. bool coveredByOtherScreen = NO;   
      248. //  loop as long as there are screens waiting to be updated
      249. while ([screensToUpdate count] > 0)   
      250.     {   
      251. //  pop the topmost screen off the waiting list
      252.         GameScreen *screen = [screensToUpdate objectAtIndex:([screensToUpdate count] - 1)];   
      253.         [screensToUpdate removeObjectAtIndex:[screensToUpdate count] - 1];   
      254. //  update the screen
      255.         [screen update:deltaTime OtherScreenHasFocus:otherScreenHasFocus   
      256.                                 CoveredByOtherScreen:coveredByOtherScreen];   
      257. if ([screen currentScreenState] == TransitionOn ||   
      258.             [screen currentScreenState] == Active)   
      259.         {   
      260. //  if this is the first active screen we came across,
      261. //  give it a chance to handle input.
      262. if (!otherScreenHasFocus)   
      263.             {   
      264.                 [screen handleInput:input];   
      265.                 otherScreenHasFocus = YES;   
      266.             }   
      267. //  if this is an active non-popup, inform any subsequent
      268. //  screens that they are covered by it
      269. if (![screen isPopup])   
      270.                 coveredByOtherScreen = YES;   
      271.         }   
      272.     }   
      273. //  do we need to print the debug trace?
      274. if (traceEnabled)   
      275.         [self traceScreens];   
      276. //
      277. //  For every screen that had their content unloaded.. release
      278. //  the memory used for that screen here. We do this up front
      279. //  to ensure that any released screen doesn't get their update
      280. //  or draw methods called, when there is nothing to update or draw.
      281. //
      282. for (GameScreen *screen in screens)   
      283.     {   
      284. if (screen.hasBeenUnloaded)   
      285.         {   
      286.             [self releaseScreen:screen];   
      287.         }   
      288.     }   
      289. }   
      290. //
      291. //  Draw the game screens from "Bottom to Top." This is done
      292. //  in order to ensure that any pop'up screens are drawn on top
      293. //  of the full screen below it.
      294. //
      295. - (void) drawView:(GLView *)view WithTime:(float)deltaTime   
      296. {   
      297. //  Clear the screen to preset color before drawing
      298.     glClear(GL_COLOR_BUFFER_BIT);   
      299. //  Draw every screen in the screens array
      300. for (GameScreen *screen in screens)   
      301.     {   
      302. //if the screens content has been unloaded, don't draw
      303. if (screen.hasBeenUnloaded)   
      304. continue;   
      305.         [screen draw:deltaTime];   
      306.     }   
      307. }   
      308. //
      309. //  Helper method designed to draw the screen names currently
      310. //  in the game stack in order to see if they are being added
      311. //  and removed correctly.
      312. //
      313. - (void) traceScreens   
      314. {   
      315. //  <<TODO: Input code to draw the screen names>>
      316. }   
      317. //
      318. //  Helper method to draw a translecent black fullscreen sprite, used
      319. //  for fading screens in and out, and for darkening the background
      320. //  behind pop up screens.
      321. //
      322. - (void) fadeBackBufferToBlack:(double)alpha   
      323. {   
      324.     glColor4f(alpha,alpha,alpha,alpha);   
      325.     [blankTexture drawInRect:self.viewport];   
      326.     glColor4f(1, 1, 1, 1);   
      327. }   
      328. //
      329. //  When the screen is touched by the user, the GLView will pass along a message
      330. //  to the view controller that the screen has been touched. The view controller
      331. //  will take the message, and pass it along to the input manager where the
      332. //  necessary information will be stored and filtered to the game screen that
      333. //  will handle the user input.
      334. //
      335. //  In order for this to work, in your GLView, you need to write the following
      336. //  4 methods:
      337. //  - (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event
      338. //  - (void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event
      339. //  - (void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event
      340. //  - (void)touchesCancelled:(NSSet *)touches withEvent:(UIEvent *)event
      341. //
      342. //  Those methods will call the methods below.
      343. //
      344. - (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event InView:(UIView *)touchView WithTimer:(NSTimer *)timer   
      345. {   
      346.     [input touchesBegan:touches withEvent:event InView:touchView  WithTimer:timer];   
      347. }   
      348. - (void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event InView:(UIView *)touchView WithTimer:(NSTimer *)timer   
      349. {   
      350.     [input touchesMoved:touches withEvent:event InView:touchView  WithTimer:timer];   
      351. }   
      352. - (void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event InView:(UIView *)touchView WithTimer:(NSTimer *)timer   
      353. {   
      354.     [input touchesEnded:touches withEvent:event InView:touchView  WithTimer:timer];   
      355. }   
      356. - (void)touchesCancelled:(NSSet *)touches withEvent:(UIEvent *)event InView:(UIView *)touchView WithTimer:(NSTimer *)timer   
      357. {   
      358.     [input touchesCancelled:touches withEvent:event InView:touchView  WithTimer:timer];   
      359. }   
      360. @end  
      361. As you can see, this is a pretty good sized class. What makes it bigger is I have a nasty habit of commenting everything to hell! I always believe it is best to comment heavily, because if you come back a year later and want to adjust your game, comments make it very helpful for remembering what does what.

        The comments in the GLViewController (screen manager) class explains what everything does, but if you have any questions feel free to post them here.

        So… now we need a game screen or two!! Remember, the following code should never be used to make a game screen directly. What I mean is, use this as a super class and inherit from it with your screens. For example, your TitleScreen should inherit from GameScreen. Make sense?

        here is the GameScreen.h file

        1. //
        2. //  A screen is a single layer that has update and draw logic, and which
        3. //  can be combined with other layers to build up a complex screen system
        4. //  or menu system, or even dialog system.
        5. //
        6. //  Developed by XNA Development Studio ( http://creators.xna.com/ )
        7. //  Modified for the iPhone Gameing Framework by Craig Giles on 1/1/09.
        8. //
        9. #import <Foundation/Foundation.h>
        10. #import <OpenGLES/EAGL.h>
        11. #import <OpenGLES/ES1/gl.h>
        12. #import <OpenGLES/ES1/glext.h>
        13. #import "InputManager.h"
        14. #import "Texture2D.h"
        15. //
        16. //  Enum to describe the screens transition state
        17. //
        18. enum ScreenState {   
        19.     TransitionOn = 0,   
        20.     Active,   
        21.     TransitionOff,   
        22.     Hidden   
        23. };   
        24. //
        25. //  Forward Declarations
        26. //
        27. @class GLViewController;   
        28. @interface GameScreen : NSObject   
        29. {   
        30. @private
        31.     GLViewController *controller;   
        32.     CGRect viewport;   
        33. bool hasBeenUnloaded;   
        34. bool isPopup;   
        35. float transitionOnTime;   
        36. float transitionOffTime;   
        37. float transitionPosition;   
        38. float transitionAlpha;   
        39. enum ScreenState currentScreenState;   
        40. bool isExiting;   
        41. bool isActive;   
        42. bool otherScreenHasFocus;   
        43. }   
        44. @property (nonatomic, retain) GLViewController *controller;   
        45. @property (readwrite) CGRect viewport;   
        46. @property (readwrite) bool hasBeenUnloaded;   
        47. @property (readwrite) bool isPopup;   
        48. @property (readwrite) float transitionOnTime;   
        49. @property (readwrite) float transitionOffTime;   
        50. @property (readwrite) float transitionPosition;   
        51. @property (readwrite) float transitionAlpha;   
        52. @property (readwrite) enum ScreenState currentScreenState;   
        53. @property (readwrite) bool isExiting;   
        54. @property (readwrite) bool isActive;   
        55. @property (readwrite) bool otherScreenHasFocus;   
        56. - (void) loadContent;   
        57. - (void) unloadContent;   
        58. - (void) handleInput:(InputManager *)input;   
        59. - (void) update:(float)deltaTime    OtherScreenHasFocus:(bool)otherFocus    CoveredByOtherScreen:(bool)coveredByOtherScreen;   
        60. - (bool) updateTransition:(float)deltaTime  TransitionTime:(float)transition    Direction:(int)direction;   
        61. - (void) draw:(float)deltaTime;   
        62. - (void) exitScreen;   
        63. @end  
        64. and the GameScreen.m file

          1. //
          2. //  A screen is a single layer that has update and draw logic, and which
          3. //  can be combined with other layers to build up a complex screen system
          4. //  or menu system, or even dialog system.
          5. //
          6. //  Developed by XNA Development Studio ( http://creators.xna.com/ )
          7. //  Modified for the iPhone Gameing Framework by Craig Giles on 1/1/09.
          8. //
          9. #import "GameScreen.h"
          10. @implementation GameScreen   
          11. //
          12. // Properties
          13. //
          14. @synthesize controller;   
          15. @synthesize viewport;   
          16. @synthesize hasBeenUnloaded;   
          17. @synthesize isPopup;   
          18. @synthesize transitionOnTime;   
          19. @synthesize transitionOffTime;   
          20. @synthesize transitionPosition;   
          21. @synthesize transitionAlpha;   
          22. @synthesize currentScreenState;   
          23. @synthesize isExiting;   
          24. @synthesize otherScreenHasFocus;   
          25. @dynamic isActive;   
          26. - (bool) isActive   
          27. {   
          28. return !otherScreenHasFocus &&   
          29.     (currentScreenState == TransitionOn ||   
          30.      currentScreenState == Active);   
          31. }   
          32. //
          33. // Constructor(s) / destructors
          34. //
          35. - (id) init   
          36. {   
          37.     self = [super init];   
          38. if (self != nil)   
          39.     {   
          40. //initializations go here
          41.         isExiting = NO;   
          42.     }   
          43. return self;   
          44. }   
          45. - (void) dealloc   
          46. {   
          47. //Deallocations go here
          48.     [super dealloc];   
          49. }   
          50. //
          51. // Loads all content associated with the current screen
          52. //
          53. - (void) loadContent   
          54. {   
          55. }   
          56. //
          57. // Unloads all content associated with the current screen
          58. //
          59. - (void) unloadContent   
          60. {   
          61. //  Release the screen manager
          62.     [controller release];   
          63. //  inidicate that the screens content has been unloaded
          64.     hasBeenUnloaded = YES;   
          65. }   
          66. //
          67. // Allows the screen to perform its update logic.
          68. //
          69. - (void) handleInput:(InputManager *)input   
          70. {   
          71. }   
          72. //
          73. //  Updates the base screen. Since any game screen
          74. //  wil be inheriting from this class, the game screen will
          75. //  call this update method. This update just helps with the
          76. //  transition between two screens, and if a screen is
          77. //  transitioning on and off.
          78. //
          79. - (void) update:(float)deltaTime    OtherScreenHasFocus:(bool)otherFocus    CoveredByOtherScreen:(bool)coveredByOtherScreen   
          80. {   
          81.     otherScreenHasFocus = otherFocus;   
          82. if (isExiting)   
          83.     {   
          84. //if the screen is going to die, it should transition off
          85.         currentScreenState = TransitionOff;   
          86. if (![self updateTransition:deltaTime TransitionTime:transitionOffTime Direction: 1])   
          87.         {   
          88. //when transition finishes, remove the screen
          89.             [controller removeScreen:self];   
          90.         }   
          91.     }   
          92. elseif (coveredByOtherScreen)   
          93.     {   
          94. //if the screen is covered by another, it should transition off
          95. if ([self updateTransition:deltaTime TransitionTime:transitionOffTime Direction: 1])   
          96.         {   
          97. //scren is still transitioning
          98.             currentScreenState = TransitionOff;   
          99.         }   
          100. else
          101.         {   
          102. //transition has finished
          103.             currentScreenState = Hidden;   
          104.         }   
          105.     }   
          106. else
          107.     {   
          108. if ([self updateTransition:deltaTime TransitionTime:transitionOnTime Direction: -1])   
          109.         {   
          110. //still busy transitioning
          111.             currentScreenState = TransitionOn;   
          112.         }   
          113. else
          114.         {   
          115. //transition finished
          116.             currentScreenState = Active;   
          117.         }   
          118.     }   
          119. }   
          120. //
          121. //  Helper method for updating the screen transition position
          122. //  (how much the screen has faded in / out)
          123. //
          124. - (bool) updateTransition:(float)deltaTime TransitionTime:(float)time Direction:(int)direction   
          125. {   
          126. //  how much should we move by?
          127. float transitionDelta;   
          128. if (time <= 0)   
          129.         transitionDelta = 1;   
          130. else
          131.         transitionDelta = deltaTime / time;   
          132. //update the transition position
          133.     transitionPosition += transitionDelta * direction;   
          134. //did we reach the end of the transition?
          135. if (direction < 0 && transitionPosition <= 0 ||   
          136.         direction > 0 && transitionPosition >= 1)   
          137.     {   
          138. //clamp transition position to 0, 1, or value;
          139. if (transitionPosition >= 1)   
          140.             transitionPosition = 1;   
          141. elseif (transitionPosition <= 0)   
          142.             transitionPosition = 0;   
          143. return NO;   
          144.     }//end "end of transition"
          145. //otherwise, we are still busy transitioning
          146. return YES;   
          147. }   
          148. //
          149. //  Each screen will have their own draw method. EVERY SCREEN
          150. //  should call [super draw:deltaTime] in order to draw
          151. //  the fade correctly when the screen manager wishes to fade
          152. //  the screen in or out.
          153. //
          154. - (void) draw:(float)deltaTime   
          155. {   
          156.     [self.controller fadeBackBufferToBlack:self.transitionPosition];   
          157. }   
          158. //
          159. // Tells the screen to go away. Unlike [controller removeScreen] which
          160. // instantly kills the screen, this method respects the transition timings
          161. // and will give the scren a chance to gradually transition off.
          162. //
          163. - (void) exitScreen   
          164. {   
          165. if (transitionOffTime == 0)   
          166.     {   
          167. //if the screen has zero transition time, kill it
          168.         [controller removeScreen:self];   
          169.     }   
          170. else
          171.     {   
          172. //otherwise flag that it should transition off and exit
          173.         isExiting = YES;   
          174.     }   
          175. }   
          176. @end  
          177. Well that does it for the screen manager and the game screen classes.. But keep in mind.. this will NOT build until the InputManager is built. Why don’t you try to fiddle with that for a while, see what you can come up with? I’ll post Part 2 of this tutorial detailing how I did my input manager and two screens (TitleScreen and PausedScreen) in my next update.

            Two thing before I go: I would really like to find a way to turn this into a template for anyone wishing to use it, but I simply do not know how. If you know how to do so, please send me an email at:
            CraigGiles9@yahoo.com

            Secondly, if you have any questions, comments, sly remarks, please post them. I am very good at reading everyones comments, and getting back to you if needed. You can either post a comment or send me an email and I’ll get back to you.

            EDIT:
            I just wanted to let everyone know that there have been a few changes to this article since first posting. I just modified the code within the GLViewController in several places. The following changes were made:
            - Added [self releaseScreen:screen]; in the dealloc method inside the for loop.
            - added const bool LANDSCAPE_MODE = NO; at the top of the view controller, and an if / else statement in the setup view method to help with setting up a landscape view rather than a portrait view. (The first screen manager was written for only portrait view)
            - added input.isLandscape = LANDSCAPE_MODE; to the loadContent method.

            Again, there are too many people to thank for helping me to get to where I am with my current knowledge. I hope this was informational to a few of you! Happy coding everyone!



출처 : http://blog.naver.com/PostView.nhn?blogId=minny0109&logNo=150052551485
Posted by 오늘마감

댓글을 달아 주세요

XCODE2010. 6. 21. 18:31
[펌] cocos2d 개발환경 설정
cocos2d-iphone 는 OpenGL ES를 기반으로 하는 게임, 에니메이션, 데모등을 위한 2D 라이브러리입니다. 기본적인 에니메이션부터 메뉴, 스코어 서버까지 지원하기 때문에 빠른 시간에 편리하게 사용할 수 있습니다. cocos2d-iphone 사이트에서 최신 버젼을 다운로드 받으실 수 있습니다.



1. cocos2d 설정
1) 빌드
다운로드를 받으신 후에 압축을 풀고 Xcode Project 파일을 클릭하여 Xcode를 실행합니다. Active Target을 cocos2d로 하고 Actvie SDK를 Device로 빌드 합니다.


Active SDK를 Simulator로 하고 다시 한번 빌드합니다.


cocos2d는 프로젝트 자체에 여러 샘플소스들을 많이 가지고 있습니다. Target을 해당 데모로 변경하여 실행을 확인해 보실 수 있습니다.

2) 라이브러리 복사
해당 폴더의 빌드 폴더를 보시면 2개의폴더에 각각 libcocos2d.a와 libChipmunk.a가 같이 빌드되어 있습니다.


원하시는 곳에 폴더를 만드시고 이 두 폴더의 파일들을 각각 다른 폴더로 가져다 놓습니다. 저는 /Developer/Library 밑에 Cocos2d란 폴더를 만들고 그 밑에 Device와 Simulator 폴더를 만들어 각각의 라이브러리 파일들을 가져다 놓았습니다.

3) 헤더파일 복사
/Developer/Library/Cocos2d 밑에 헤더파일들을 복사하기 위해 Include 폴더를 새로 만듭니다. Include 폴더의 하위로 Support 폴더를 만듭니다. 다시 cocos2d 폴더로 와서 보시면 하위에 똑 같은 이름의 cocos2d란 폴더가 있습니다. 이 폴더내의 *.h을 위에서 생성한 Include 폴더로 복사합니다. 하위의 Support 폴더내의 *.h 파일도 해당 폴더의 Support 폴더내로 복사합니다. (파인더에서 정렬을 종류로 하시면 헤더파일별로 쉽게 가져 올 수 있습니다.)


그리고 cocos2d 폴더의 external/Chipmunk/src에 있는 *.h 파일도 위와 같이 생성한 Include 폴더로 복사합니다. Chipmunk는 게임등에 사용되는 물리엔진으로 컴파일을 위해 헤더파일이 꼭 필요하며 실제 사용하지 않을 경우에는 라이브러리는 추가하지 않으셔도 됩니다.

4) fps_images.png 복사
cocos2d가 초당 프레임수를 출력할 때 사용하는 이미지를 해당 프로젝트의 Resource 폴더에 복사해 놓으셔야 됩니다. 이 이미지가 없을 경우에는 아래와 같은 실행오류가 발생합니다.


cocos2d 폴더의 Resources/Images에 있는 fps_images.png 파일을 적당한 위치에 복사해 놓습니다.



2. Xcode 설정
Xcode에서 New Project를 클릭하여 iPhone OS/Application의 Window-Based Application으로 프로젝트를 생성합니다. 프로젝트명을 cocos2d App로 입력합니다.

1) Search Paths 설정
좌측과 같이 Groups & Files에서 프로젝트를 우클릭한 후에 Get Info를 클릭하여 Project 정보창을 오픈합니다.

두번째 Build에서 Search Paths항목에서 Header와 Library를 각각 해당 폴더로 입력합니다.

아래와 같이 Header Search Paths, Library Search Paths가 입력되어 있는 것을 확인합니다.

2) cocos2d 라이브러리 링크
Linking 항목중 OPther Linker Flags에 -lcocos2d를 입력합니다.


libcocos2d.a를 드래그 해서 직접 추가하여 사용하셔도 됩니다. 하지만 시뮬레이터와 디바이스의 선택에 따라 각각의 라이브러리 파일이 필요하기 때문에 Active SDK가 변경될 경우에는 매번 파일을 변경해 주어야 합니다.

그렇기 때문에 설정에서 Configuration이 Debug일때는 Library Search Paths를 Simulator로 Release일 때는 Device로 설정합니다. 시뮬레이터로 개발시에는 Debug 모드로 개발하고 실제 기기에서 테스트시나 업로드시에는 Release 모드를 선택하면 해당 라이브러리 파일의 변경없이 편하게 사용하실 수 있습니다.

3) 프레임워크 추가
cocos2d가 사용하는 OpenGL ES, QuartzCore 프레임워크를 추가합니다. 좌측과 같이 cocos2d App 타겟에 우클릭하여 Get Info를 클릭합니다.



General 항목의 좌측 하단에 [+] 버튼을 클릭합니다.
아래와 같이 OpenGLES.framework와 QuartzCore.framework를 선택하고 Add를 클릭합니다.


4) fps_images.png 추가
좌측과 같이 이전에 복사해 두었던 fps_images.png를 Resources 항목으로 드래그해서 가져다 놓습니다.



5) 프로젝트 템플릿 추가
cocos2d를 사용할 때마다 매번 위의 설정을 하는 것은 번거로운 작업입니다. 그렇기 때문에 기본설정된 항목을 템플릿에 추가하여 사용하는 것이 편리합니다. cocos2d App 프로젝트 폴더를  /Library/Application Support/Deveoper/Shared/Xcode/Project Templates/ 밑에 Application 폴더를 만드시고 그 아래에 복사합니다.
이제 새 프로젝트를 선택하면 User Templates/Application에 cocos2d App 항목이 나오며 위에서 cocos2d를 위해 설정된 사항대로 편리하게 사용하실 수 있습니다.

cocos2d에 관한 자세한 내용과 자료는 cocos2d-iphone 사이트에서 확인하실 수 있습니다.


출처 : http://blog.naver.com/PostView.nhn?blogId=minny0109&logNo=150066882426

'XCODE' 카테고리의 다른 글

유용한 XCode Shortcuts..  (0) 2010.06.22
Xcode 단축키  (0) 2010.06.21
[펌] cocos2d 개발환경 설정  (0) 2010.06.21
NSNumber, NSMutableArray 초기화 및 사용법  (0) 2010.06.21
[xcode 팁] .h과 .m 파일 이동하기  (0) 2010.06.21
OSX 화면 캡쳐 방법  (0) 2010.06.21
Posted by 오늘마감

댓글을 달아 주세요

아이폰어플개발정보2010. 6. 21. 09:32
[펌] 노티피케이션(Notification) 사용하기
*주의: Push Notification service에 관한 내용이 아닙니다



http://cafe.naver.com/mcbugi/21370  에 올린 델리게이트에 관한 내용에 이어서 이번에는 노티피케이션에 관한 내용을 적어 봅니다..

이전과 마찬가지로 가장 심플한 수준의 코드로 샘플코드를 만들 것이니 복잡한 활용법은 스스로 문서등을 참조해서 깨우치도록(?) 하세요..


델리게이트와 마찬가지로 NSNotification도 오브젝트간의 통신을 위한 많은 방법들 중에 하나입니다. Delegate보다 사용법은 심플하고 강력하지만 잘못쓰면 코드가 엉망이 될 위험부담도 큰 놈입니다. 개념은 매우 단순합니다.

노티피케이션 센터란놈에 특정 메세지를 등록해두고 이 메세지가 불리어지면 다른 여러 오브젝트에 등록된 옵져버들이 메세지에 반응해서 이벤트를 처리해주는 식입니다.

노티피케이션의 강력한점은 동시에 여러오브젝트에 메세지를 전달한다는 점입니다. 

자.. 그럼 샘플코드를 만들어 보도록 합시다.  


텝바 베이스로 4개의 뷰컨트롤러를 가진 프로그램입니다. 각각의 뷰컨트롤러간에는 아무런 연관 관계도 없고 1번 뷰컨트롤러에서 메세지를 보내면 2,3,4번 뷰컨트롤러가 노티피케이션 옵져버에 의해서 메소드를 불러와서 값이 갱신되도록 하겠습니다.

먼저 4개의 뷰컨트롤러를 가진 프로그램을 만들었습니다. 이동은 탭바로 하지만 아무것도 없으니 너무 허전하내요..






일단 1번 뷰컨트롤러에는 텍스트 필드를 만들고 2,3,4번에는 1번 뷰컨트롤러의 텍스트 필드에 입력한 텍스트 값이 2,3,4번에 노티피케이션에 의해서 동시에 갱신되도록 만들겠습니다.

먼저 1번 뷰 컨트롤러 입니다. init함수에 텍스트 필드 하나를 위치시켰습니다.



FirstViewControllert.m

-(id) init{

     self = [superinit];

     if (self != nil) {

          textField = [[UITextFieldalloc] initWithFrame:CGRectMake(10, 10, 300, 25)];

          textField.delegate = self;

          textField.borderStyle = UITextBorderStyleRoundedRect;

          [self.view addSubview:textField];

     }

     returnself;

}


그리고 텍스트필드에서 완료를 누르면 키보드가 사라지면서 값을 저장하기 위해서 델리게이트 함수를 구현했습니다.


-(BOOL) textFieldShouldReturn:(UITextField *)_textField{

     //키보드내리기

     [_textField resignFirstResponder];

     //파라메터로넘길텍스트필드의스트링을딕셔너리에넣습니다

     NSDictionary *dic = [NSDictionarydictionaryWithObject:_textField.textforKey:@"inputText"];

     //노티피케이션센터에라벨을갱신하라고메세지를보냅니다. 파라메터는 NSTimer처럼 userInfo를이용해서텍스트필드의내용을파라메터로보내줬습니다. 보통 NSDictionary타입으로보내줍니다

     NSNotificationCenter *nc = [NSNotificationCenterdefaultCenter];

     [nc postNotificationName:@"saveTextFieldText"object:selfuserInfo:dic];

     returnYES;

}



키보드의 완료 버튼을 누르면 키보드가 내려가면서 입력받은 텍스트를 노티피케이션 센터에 saveTextFieldText 

메시지와 함께 전송을 합니다. 

**메세지는노티센터에서공통으로쓰기때문에될수있으면구체적이고알기쉽게.. 나중에노티피케이션메세지가많아지면관리가 엉말이될수있습니다.


이제 노티피케이션 센터에서 보낸 메세지에 반응하도록 다른 뷰컨트롤러들을 수정해 줍시다.



SecondViewController.m


-(id) init{

     self = [superinit];

     if (self != nil) {

          notificationLabel = [[UILabelalloc] initWithFrame:CGRectMake(10, 10, 300, 25)];

          notificationLabel.backgroundColor = [UIColorblueColor];

          [self.viewaddSubview:notificationLabel];

          NSNotificationCenter *nc = [NSNotificationCenterdefaultCenter];

          [nc addObserver:selfselector:@selector(saveText:) name:@"saveTextFieldText"object:nil];

     }

     returnself;

}


addObserver소드로 노티피케이션 센터에서 해당 메시지(saveTextFieldText)가 넘어오면 saveText: 메소드가 핸들링되게 설정을 해놨습니다. 다른 뷰컨트롤러도 동일하게 등록해주면 됩니다.


-(void)saveText:(NSNotification *)note{

     NSString *text = [[note userInfo] objectForKey:@"inputText"];

     notificationLabel.text = text;

}


실제 노티피케이션으로 메시지가 넘어왔을때 핸들링 하는 함수입니다. note의 userInfo는 이전에 userInfo로 넘긴 정보가 그대로 들어있으니 파라메터로 받아와서 라벨의 텍스트를 갱신 시켰습니다.



실제로 잘 작동하는 가볼까요?


노티피케이션 메세지가 잘넘어가는군요~ 잘만 활용하면 강력한 노티피케이션을 간단하게 이용해봤습니다.

그밖에 응용은 적당히 잘하시기 바랍니다, 그럼 이만 물러갑니다



출처 : http://blog.naver.com/PostView.nhn?blogId=seogi1004&logNo=110087701542
Posted by 오늘마감

댓글을 달아 주세요

아이폰어플개발정보2010. 6. 21. 09:32
[펌] 아이폰 프로그래밍에서 객체의 직렬화 방법
아이폰객체의직렬화방법


아이폰프로그래밍으로객체를저장하거나(파일로혹은DB) 네트워크로보내거나할려면다른플랫폼과마찬가지로직렬화(Serialization) 과정을거쳐야합니다

코코아프레임웍에서는직렬화를위해오브젝트를엔코딩/디코딩해주는편리한클래스를제공하고있는데아이폰에서사용가능한놈은 NSCoder를상속받은 NSKeyedArchiver NSKeyedUnarchiver입니다(아이폰에서 NSArchiver는사용불가니주의)


그럼간단한사용방법을보도록하죠


먼저 NSString 오브젝트를 NSData타입으로직렬화해보도록하겠습니다


엔코딩

NSString *str = @"블라블라블라";

NSData *data = [NSKeyedArchiverarchivedDataWithRootObject:str];



디코딩

NSString *str2 = [NSKeyedUnarchiver unarchiveObjectWithData:data];


이렇게 됩니다. 참간단하죠? 하지만 주의해야할 점이 있습니다. NSKeyedArchiver 인코딩/디코딩 가능한 오브젝트는 반드시 NSCoding프로토콜 불러오고 object내부에   -initWithCoder, -encodeWithCoder 메소드를 구현해줘야합니다. NSCoder 이게 없으면 오브젝트를 어떻게 인코딩/디코딩할지 못알아 먹겠죠..


일단 자주 쓰는 데이터 저장을 위한 대부분의 클래스들은 NSCoding 지원하고 있으니 특별히 손대줄 필요가 없습니다.(NSString , NSDictionary, NSArray... 등등등)



그럼다양한데이터를가진직접만든 Object를가지고해보도록하겠습니다.


UserObject.h


@interface UserObject : NSObject <NSCoding> {   //NSCoding 프로토콜을채용

NSString *str;

int int1;

double double1;

UIImage *img;

}

@property구현



이렇게 NSString 객체,UIImage객체 , 정수형,실수형 데이터를 가진 오브젝트 입니다. 그럼 본격적으로   -initWithCoder, -encodeWithCoder 구현을 해보겠습니다. 메소드의 구현은 NSDictionary등에서 익숙현 키벨류 방식으로 만들어 주면 됩니다.


UserObject.m


//먼저인코딩메소드입니다.

-(void) encodeWithCoder:(NSCoder*) coder{

@"string"];  
[coder encodeDouble:double1 forKey:@"double"]; // object 이외의 실수형이나 정수형 데이터는 각각에 맞는 엔코딩/디코딩 메소드를 가지고 있습니다
encodeInt:int1 forKey:@"int"];
안타깝게 UIImage 클래스 레퍼런스를 확인하면 NSCoding 지원하지 않습니다. 그렇기 때문에 이와같이 하면 에러가 납니다. 그렇게 때문에 UIImagePNGRepresentation메소드를 이용해서 UIImage 이미지를 NSData타입으로 바꾼다음에 집어넣으면 됩니다.
[coder encodeObject:UIImagePNGRepresentation(img) forKey:@"img"];

}


//그다음디코딩메소드입니다. 짝을맞춰줍시다.


-(id) initWithCoder:(NSCoder *)decoder{

if(self = [superinit]{

self.str = [decoder decodeObjectForKey:@"string"];

self.double1 = [decoder decodeDoubletForKey:@"double"];

self.int1 = [decoder decodeIntForKey:@"int1"];

self.img = [UIImageimageWithData:[decoder decodeObjectForKey:@"img"]];

}

;

}

이런식으로아무리복잡한데이터형태의오브젝트라도엔코딩/디코딩메소드만구현해주면쉽게직렬화가됩니다. 이상입니다~

http://cafe.naver.com/mcbugi/17649



출처 : http://blog.naver.com/PostView.nhn?blogId=seogi1004&logNo=110087700353
Posted by 오늘마감

댓글을 달아 주세요

오브젝트C2010. 6. 21. 09:31
[펌] Delegate

Objecive-C를 좀 보고, Xcode 좀 봐보고 Interface Builder 좀 보고 Hello, World 같은 거 한 번 만들어보고...

슬슬 깊이 들여다보려고 하면 많이 눈에 띄는 것들이 있다.
어쩌구View, 어쩌구Controller 그리고 어쩌구Delegate 이런것들이다.
그 중에 오늘은 delegate에 대해서 한 번 알아보자. 이건 맥/아이폰/팟용 어플을 개발하는데 꼭 알고 넘어가야 할 부분이다.

뭔가 낯설은 단어 delegate. 그치만 단어 그 자체로 받아들이면 된다. 대리인.
delegate을 처음 접한다면 아직 뭔소린지 잘 감이 오질 않을것이다. 그치만 이 글을 다 읽고 나면, 아! delegate 대리인!이 머리속에 자리잡힐 것이다.

우선 기존 개발을 하시던 분이라면,
서브클래싱, 혹은 클래스를 상속받아서 새로운 클래스를 만들어서 사용하는 것
또는 델파이/C++Builder 쪽에서 보면 Event 같은 것이라고 볼 수 있다.

자 그럼 본격적으로.....
UITextField 클래스를 예로 들어보자. UITextField는 사용자에게 텍스트를 입력받는 기능을 하는 클래스이다.
이 클래스의 인스턴스를 하나 만들고 사용을 하면, text 속성을 통해서 입력받은 텍스트를 알아낼 수 있고 textColor 속성으로 글자의 색을 변경할 수 있는 등의 작업을 할 수 있다.

그런데, 만일 이 TextField에서 사용자가 키보드 입력을 시작했을 때 특정한 일을 하게 하고 싶으면 어떻게 할까?
(델파이/C++Builder 사용하는 개발자라면, Edit1->OnChange=Edit1Change; 로 이벤트 연결을 시켜주면 될 것이다.)
Cocoa에서는 TextField에 delegate(대리인)을 지정해주고 그 delegate(대리인)이 지정된 함수를 만들고 그 안에서 하고자 하는 일을 하면 된다.

UITextField *textField;
}
@end

@implement MyController
-(id)init {
if(self = [super init]) {
textField = [[UITextField alloc] init];
textField.delegate = self; // MyController를 textField의 delegate(대리인)으로 지정한다.
// MyController가 textField에서 지정된 역할을 처리할 수 있게 되었다는 의미이다. 
}
return self;
}
// UITextFieldDelegate의 Method 구현
// UITextFieldDelegate를 도움말에서 찾으면 어떤 Method들이 있는지 확인해볼 수 있고,
// 거기서 필요한 것들을 구현해주면 된다.
- (void)textFieldDidBeginEditing:(UITextField *)textField {
// 이곳에 textField에서 사용자가 무언가 입력을 시작할 때 
// 처리하고 싶은 일을 처리하면 된다.
}
@end

UITextField의 Instance인 textField는 사용자가 텍스트 입력을 시작하면, delegate가 지정되어 있다면 delegate에게 "야! 사용자가 입력시작했다. 뭐 처리할 것 있으면 해!"라고 알려준다. 그럼 delegate(대리인, 위 예에서는 MyController)는 지정된 함수를 구현하고 있으면 되는 것이다.

필수로 구현해야하는 것들도 있고, 옵션으로 필요한 경우에만 구현해도 되는 것들이 있으니 도움말을 참고해서 필요한 것들을 구현해주면 된다.


자, 그럼 이번에는 내가 만드는 클래스에서도 delegate를 한 번 만들어 사용해보자.
//-------------------------------------- MyTestDelegate interface
@interface NSObject (MyTestDelegate)
-(void) testDidBeginSomething:(UIMyClass*)myClass;
-(void) testDidEndSomething;(UIMyClass*)myClass withArgument:(int)arg;
@end
//-------------------------------------- MyTestClass interface
@interface MyTestClass{
id delegate;
...
}
@property (nonatomic, assign) id delegate;
-(void) myMethod1;
-(void) myMethod2;
...
@end;
//-------------------------------------- MyTestClass implementation
@implement MyTestClass
@synthesize delegate;
-(void) myMethod1 {
...
if(delegate && [delegate respondsToSelector:@selector(testDidBeginSomething:)])
[delegate testDidBeginSomething:self];
...
}
-(void) myMethod2 {
...
if(delegate && [delegate respondsToSelector:@selector(testDidEndSomething:withArgument:)])
[delegate testDidEndSomething:self withArgument:100];
...
}
@end
//-------------------------------------- MyTestController interface
@interface MyTestController {
MyTestClass *test;
...
}
...
@end
//-------------------------------------- MyTestController implementation
@implementation MyTestController
-(id)init {
if(self = [super init]) {
test = [[MyTestClass alloc] init];
test.delegate = self; // MyTestController를 test의 delegate로 지정
}
return self;
}
// MyTestClass의 delegate로써 처리할 method들 구현
-(void)testDidBeginSomething:(MyTestClass*)testClass {
// 이곳에 처리할 일들을 처리하면 됨.
// 처리해야할 것이 없으면 이 Method 자체를 구현 안해도 됨.
}
-(void)testDidEndSomething:(MyTestClass*)testClass withArgument:arg1 {
// 이곳에서도 처리할 일들을 처리하면 됨.
// 처리해야할 것이 없으면 이 Method 자체를 구현 안해도 됨.
}
@end

delegate interface를 선언하는 방법은 위처럼 NSObject (Delegate이름) 을 이용해서 선언할 수도 있고, protocol 을 사용할 수도 있는데, protocol을 사용하는 방법은 다음번에 기회가 되면 설명하도록 하겠다.
혹 지금 당장 궁금하다면, 구글링을 하러 고고! (대략 delegate가 어떤 것인지 감이 잡혔다면 금방 이해가 될 것이다.)

아이폰/팟 어플리케이션에서는 UITableView를 이용하는 경우가 많은데, delegate에 대해 감을 잡고 있으면 쉽게 사용할 수 있다. 도움말에서 UITableView와 UITableViewDelegate를 한 번 찾아서 살펴보면 음..이렇게 구성되어 있구나..라고 생각하면 된다.


갑자기 엉뚱한 소리지만, Cocoa를 공부하면서 다시 한 번 C++Builder(델파이) 사용자로서....C++Builder/델파이가 참 초직관적으로 잘 만들어져있다는 생각이 든다......Visual Studio에서 MFC사용하는 것에 비해서는 두말할 나위도 없이...
다 나름대로의 장단점들이 있겠지만, 직관성에 있어서는 C++Builder/델파이가 압승!


출처 : http://blog.naver.com/PostView.nhn?blogId=seogi1004&logNo=110087691887

'오브젝트C' 카테고리의 다른 글

Objective-C에만 있는 상수 및 문법  (0) 2010.06.21
OSX를 VMware 설치후 해상도 변경  (0) 2010.06.21
[펌] Delegate  (0) 2010.06.21
[펌] Key-Value Coding  (0) 2010.06.21
[Objective-C] 동적으로 메소드 호출하기  (0) 2010.06.21
[펌] 메소드의 포인터, IMP란?  (0) 2010.06.21
Posted by 오늘마감

댓글을 달아 주세요

오브젝트C2010. 6. 21. 09:31
[펌] Key-Value Coding

Cocoa string(key)통하여객체의어떤 instance variable값을가져오거나설정하는방법을제공한다. 이것을 key-value coding(KVC)이라고한다. KVC에서는먼저 key들어온 string같은이름을갖는 instance variable accessor method찾아이를실행하여값을가져오거나설정한다. 만약해당 accessor method존재하지않으면직접 instance variable접근하여작업을수행한다. 다음은 key-value coding통하여 Book객체인 book instance variable 하나인 title값을가져오고설정하는코드이다.


    NSString* title = [book valueForKey:@"title"];

    [book setValue:@"Harry Potter"forKey:@"title"];



  Object아닌int, float, struct같은 scalar value NSNumber 또는 NSValue wrapping하여사용한다. 다음은 bookint타입 variable page값을가져오고설정하는코드이다


    NSValue* page = [book valueForKey:@"page"];

    [book setValue:[NSNumbernumberWithInt:540] forKey:@"page"];



  Object(book) sub-object(author)포함하는경우 key path통하여 sub-object instance variable접근할있다.


    NSString* name = [book valueForKeyPath:@"author.name"];

    [book setValue:@"Celete"forKeyPath:@"author.name"];



  Object(library) sub-object-array(books)포함하는경우그에해당하는모든값들이 array 형태로리턴되거나새로운값으로바뀌게된다.

    

    NSArray* titles = [library valueForKeyPath:@"books.title"];

    [library setValue:@"Harry Potter"forKeyPath:@"books.title"];



  Key path @count, @sum, @avg, @max, @min, @distinctUnionOfObjects 등과같은 operator들과함께쓰여특별한기능을있다.


    NSNumber* numberOfBooks = [library valueForKeyPath:@"books.@count"];

    NSNumber* sumOfPagesOfBooks = [library valueForKeyPath:@"books.@sum.page"];

    NSNumber* avgPagesOfBooks = [library valueForKeyPath:@"books.@avg.page"];



위와같이 key path operator key path 중간에끼어역할을한다. (operator중간에끼어있는게처음에는이상하게느껴졌는데, 지금보니중간에끼어있는게 readability높여주는같다. 예를들어@"books.@sum.page""books에서 sum of page구하여라"라고자연스럽게읽힌다.


  @distinctUnionOfObjects결과에서중복된것이없도록만들어준다.


    NSArray* authors = [library valueForKeyPath:@"books.@distinctUnionOfObjects.author"];



다음과같이 key들의 array넘겨 key그에해당하는 valueNSDictionary형태로받아볼수도있다

                                                      

    NSArray* keys = [NSArrayarrayWithObjects:@"title", @"page", @"author", nil];

    NSDictionary* bookValues = [book dictionaryWithValuesForKeys:keys];


또는다음과같이 key그에해당하는 value저장된NSDictionary넘겨 object instance variable값들을설정할수도있다.


    NSDictionary* values = [NSDictionary dictionaryWithObjectAndKeys:

                                       @"Harry Potter", @"title",

                                       [NSNumbernumberWithInt:540], @"page",

                                       @"J.K. Rolling", @"author",

                                       nil];

    [book setValueForKeysWithDictionary: values];




  setNilValueForKey 메소드를 override하여int, float같은 scalar value들을nil설정할있도록있다.

                                                      

    - (void) setNilValueForKey: (NSString*) key

    {

        if ([key isEqualToString:@"page"])

        {

            page = 0;

        }

        else

        {

            [supersetNilValueForKey:key];

        }

    }

     

    

    [book setValue:nilforKey:@"page"];




Reference

[1] Dalrymple. M., Learn Objective-C on the Mac, Apress.



출처 : http://blog.naver.com/PostView.nhn?blogId=seogi1004&logNo=110086941695

'오브젝트C' 카테고리의 다른 글

OSX를 VMware 설치후 해상도 변경  (0) 2010.06.21
[펌] Delegate  (0) 2010.06.21
[펌] Key-Value Coding  (0) 2010.06.21
[Objective-C] 동적으로 메소드 호출하기  (0) 2010.06.21
[펌] 메소드의 포인터, IMP란?  (0) 2010.06.21
[펌] Objective-C 생성자  (0) 2010.06.21
Posted by 오늘마감

댓글을 달아 주세요

오브젝트C2010. 6. 21. 09:31
[펌] 메소드의 포인터, IMP란?
[출처] http://wisdom.sakura.ne.jp/programming/objc/index.html
아래의 문서는 위 사이트의 objective-c 강좌를 번역한 내용입니다.
번역기를 돌린 것이므로, 이상한 부분도 있을 수 있음을 참고 해주세요.

메소드를 함수로서 호출한다

사실, Objective-C 의 메소드는 C 언어의 함수와 같습니다. 평상시는

Objective-C 의 메소드는, 항상 IMP 형태이다고 정의됩니다. IMP 형태는,

typedef id (*IMP)(id, SEL, ...);

이 정의로부터도 알 수 있듯이, Objective-C에서 선언된 모든

+ (IMP)instanceMethodFor:(SEL)aSel;

- (IMP)methodFor:(SEL)aSel;

aSel 에는 대상 메소드의 IMP, 즉 함수 포인터를 취득하고 싶은 selecotr를 지정합니다. 메소드는, aSel로 지정된 selector가 특정하는 메소드의 포인터를 돌려줍니다.

 

포인터를 취득할 수 있으면, C 언어에서도 인스턴스 메소드를 호출할

#import <stdio.h>
#import <objc/Object.h>

@interface Test : Object
- (void)Write;
@end

@implementation Test
- (void)Write

{
 printf("I am the bone of my sword.\n");
}
@end

int main()

{
 id obj;
 SEL method;
 IMP func;

 obj = [Test new];
 method = @selector(Write);
 func = [Test instanceMethodFor:method];
 func(obj , method);

 return 0;
}


이 프로그램은, Test

'오브젝트C' 카테고리의 다른 글

[펌] Key-Value Coding  (0) 2010.06.21
[Objective-C] 동적으로 메소드 호출하기  (0) 2010.06.21
[펌] 메소드의 포인터, IMP란?  (0) 2010.06.21
[펌] Objective-C 생성자  (0) 2010.06.21
[강좌] From C++ to Objective-C  (0) 2010.06.21
[펌] id 타입에 대해서...  (0) 2010.06.21
Posted by 오늘마감
TAG IMP란?, [펌], 메소드의, 포인터
Trackback 1 Comment 0

댓글을 달아 주세요

«이전  1 2 3 4 5 6  다음»