아이폰어플개발정보2010. 6. 21. 23:55
[번역] Getting started with iPhone

iPhone OS 를 시작하기

iPhone OS iPhone iPod 터치 장치들을 위한 어플리케이션을 만들기 위해서 여러분이 사용하는 운영 시스템과 기술을 포괄적으로 의미합니다. iPhone OS 안의 기술은 터치 이벤트에 응답하고 고품질의 그래픽을 출력하는 향상된 어플리케이션을 만들기 위해 여러분에게 필요한 모든 것을 제공합니다. 이러한 기본적인 어플리케이션 환경에 더불어, iPhone OS 는 여러분에게 멀티-터치 이벤트로의 접근, 하드웨어 가속도계로의 접근, 향상되고 진보된 어플리케이션을 쉽게 만들게 하는 장치에서 제공하는 기능의 접근을 제공합니다.

iPhone SDK iPhone OS, Xcode 툴들, 그리고 문서와 샘플 코드, 여러분이 어플리케이션을 개발할 때 필요로 하는 리소스를 갖고 있습니다. iPhone SDK Xcode 툴들은 Mac OS X v10.5 혹은 그 이상 버전이 실행되고 있는 인텔 기반의 맥킨토시에서 사용될 수 있습니다. Xcode 는 여러분의 어플리케이션 코드를 생성하고, 컴파일하고, 실행하고, 디버깅하는데 필요한 개발 환경을 제공합니다. Xcode 는 완벽히 iPhone OS 에 통합되어 있기 때문에, 이것을 갖고 iPhone 어플리케이션을 개발하는 것은 어렵지 않습니다.

iPhone SDK 를 얻는 방법은 아래의 링크를 찾아가세요. http://developer.apple.com/iphone/[] [iPhone OS Overview] [] [Tools for iPhone OS Development] [] [Learning Objective-C: A Primer] Creating an iPhone Application] MoveMe]

[] iPhone Development Guide [] iPhone Application Programming Guide iPhone [] Your First iPhone Application [] iPhone Human Interface Guidelines [] Cocoa Fundamentals Guide [] The Objective-C Programming Language iPhone OS Technology Overview §Getting Started with Audio & Video

§Getting Started with Data Management

§Getting Started with Graphics and Animation

§Getting Started with Networking & Internet

§Getting Started with Performance

§Getting Started with Security

§Getting Started With User Experience

Posted by 오늘마감

댓글을 달아 주세요

아이폰어플개발정보2010. 6. 21. 22:48
[iPhone] iPhone SDK 다운로드
 
 

현재 http://developer.apple.com/iphone/ 에서는 아이폰 SDK 3.2 만 다운로드 받을 수 있게 되어 있습니다. 아이폰 SDK 3.2 는 OSX 10.6.2 버전 이상에서만 설치되더군요. 그래서, 하위 버전의 아이폰 SDK 가 필요해서 구글 검색하다가 아래의 링크 리스트를 발견하게 되었어요.

해당 SDK 를 다운로드 받고 싶으신 분은 아래의 경로 링크에서 오른쪽 마우스 버튼을 클릭하신 후, "다른 이름으로 대상 저장" 메뉴를 클릭하시면 다운로드되어서 저장될 파일을 선택하고 다운로드 받으시면 됩니다.

iPhone SDK 2.2.1 direct download link
http://developer.apple.com/iphone/download.action?path=/iphone/iphone_sdk_for_iphone_os_2.2.1__9m2621a__final/iphone_sdk_for_iphone_os_2.2.19m2621afinal.dmg

iPhone SDK 2.2 direct download link
http://developer.apple.com/iphone/download.action?path=/iphone/iphone_sdk_for_iphone_os_2.2__9m2621__final/iphone_sdk_for_iphone_os_2.2_9m2621_final.dmg

iPhone SDK 3.0 (Xcode 3.1.3) Leopard direct download link
http://developer.apple.com/iphone/download.action?path=/iphone/iphone_sdk_3.0__final/iphone_sdk_3.0__leopard__9m2736__final.dmg

iPhone SDK 3.0 (Xcode 3.2) Snow Leopard direct download link
http://developer.apple.com/iphone/download.action?path=/iphone/iphone_sdk_3.0__final/iphone_sdk_3.0__snow_leopard__final.dmg

iPhone SDK 3.1 with Xcode 3.1.4 Leopard direct download link
http://developer.apple.com/iphone/download.action?path=/iphone/iphone_sdk_3.1__final/iphone_sdk_3.1_with_xcode_3.1_final__leopard__9m2809.dmg

iPhone SDK 3.1 with XCode 3.2.1 for Snow Leopard
http://developer.apple.com/iphone/download.action?path=/iphone/iphone_sdk_3.1__final/iphone_sdk_3.1_with_xcode_3.2_final__snow_leopard__10a432.dmg

iPhone SDK 3.1.2 with XCode 3.1.4 for Leopard
http://developer.apple.com/iphone/download.action?path=/iphone/iphone_sdk_3.1.2__final/iphone_sdk_3.1.2_with_xcode_3.1.4__leopard__9m2809.dmg

iPhone SDK 3.1.2 with XCode 3.2.1 for Snow Leopard
http://developer.apple.com/iphone/download.action?path=/iphone/iphone_sdk_3.1.2__final/iphone_sdk_3.1.2_with_xcode_3.2.1__snow_leopard__10m2003.dmg

iPhone SDK 3.1.3 with XCode 3.1.4 for Leopard
http://developer.apple.com/iphone/download.action?path=/iphone/iphone_sdk_3.1.3__final/iphone_sdk_3.1.3_with_xcode_3.1.4__leopard__9m2809a.dmg

iPhone SDK 3.1.3 with XCode 3.2.1 for Snow Leopard
http://developer.apple.com/iphone/download.action?path=/iphone/iphone_sdk_3.1.3__final/iphone_sdk_3.1.3_with_xcode_3.2.1__snow_leopard__10m2003a.dmg

iPhone SDK 3.2 beta 4 with Xcode 3.2.2 (Snow Leopard)
http://developer.apple.com/iphone/download.action?path=/iphone/iphone_sdk_3.2_beta_4/iphone_sdk_3.2_beta_4_with_xcode_3.2.2.dmg

iPhone SDK 3.2 with Xcode 3.2.2 (Snow Leopard)
http://developer.apple.com/iphone/download.action?path=/iphone/iphone_sdk_3.2__final/xcode_3.2.2_and_iphone_sdk_3.2_final.dmg


출처 : http://blog.naver.com/PostView.nhn?blogId=cbdman&logNo=130084730320
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 오늘마감

댓글을 달아 주세요

아이폰어플개발정보2010. 6. 21. 18:30
[팜] iPhone 어플리케이션 개발을 위한 준비 - 2. 소프트웨어
2. 소프트웨어
아이폰 어플리케이션을 위해 준비해야될 소프트웨어는 Xcode와 iPhone SDK 입니다. 내용은 조금 길지만 요약하면 ADC 맴버쉽 프로그램에 가입 후에 Xcode와 iPhone SDK를 다운로드 받아 설치하시면 됩니다. 맴버쉽 프로그램 등록, 개발 툴 모두 무료입니다.

1) Xcode 와 iPhone SDK 설치
1.1) ADC 가입
Xcode와 iPhone SDK는 모두 무료로 제공됩니다. 하지만 다운로드 받기 위해서는 ADC (Apple Developer Connection) 멤버쉽 프로그램에 가입하셔야 됩니다. (Xcode는 설치CD에 포함되어 있지만, 최신버젼을 얻기 위해서는 다운로드 받아서 설치하시는 것을 권장합니다.)  ADC는 애플이 제공하는 개발에 관련된 각종 툴, 문서, 샘플코드등을 제공하는 서비스입니다. 현재는 아래와 같이 아이폰과 맥, 두개의 색션으로 분리되어 있습니다.


ADC 회원은 지원범위에 따른 여러 유료회원도 있지만, 무료인 온라인 회원으로 가입하셔도 개발툴과 관련 문서, 샘플코드를 사용할 수 있습니다. ADC회원가입과 Xcode, iPhone SDK 설치에 관한 자세한 내용은 Xcode 3 다운로드 및 설치란 포스팅을 참고 하시기 바랍니다.

1.2) Xcode
Xcode는 애플에서 제공하는 OS X에서 맥/아이폰 어플리케이션 개발을 위한 대표적인 개발툴입니다. GCC를 컴파일러로 사용하는 Xcode는 Objective-C, C/C++, Java, Ruby, Python등의 언어를 지원하며, GUI 어플리케이션뿐만 각종 커멘드라인 유틸리티, 프레임워크, 라이브러리, 드라이버등 맥과 아이폰에서 사용하는 다양한 실행 바이너리를 만들 수 있습니다.


* 인터페이스 빌더
Xcode는 맥과 아이폰의 GUI 디자인을 위한 툴로 인터페이스 빌더(IB)를 제공합니다. IB는 OS X 어플리케이션에서 사용하는 nib 파일을 생성해 줍니다. nib에 대한 자세한 설명은 nib 파일 둘러보기란 포스팅을 참조하시기 바랍니다.
 


1.3) 아이폰 시뮬레이터
Xcode 와 iPhone SDK를 설치하면 아이폰 시뮬레이터를 사용할 수 있습니다. 시뮬레이터는 아이폰이나 아이팟 터치가 없더라도, 맥에서 만든 어플리케이션을 실행할 수 있는 아이폰의 에뮬레이터 입니다. 마우스로 터치 UI를 시연해 볼 수 있으며, 회전도 가능합니다.



2) 아이폰 개발자 프로그램 가입
아이폰 어플리케이션을 개발 후에 배포 및 판매를 위해서는 반드시 아이폰 개발자 프로그램에 가입을 하셔야 됩니다. 스텐다드와 엔터프라이즈 두개의 프로그램이 있으며 각각 $99, $299의 비용이 들어 갑니다. (1년마다 같은 비용으로 자격을 연장하셔야 합니다) 차이점은 개발한 어플리케이션을 App 스토어에 등록을 하여 배포를 하는지 또는 직접 배포를 하는지의 여부입니다.


개발자 프로그램에 가입을 하시면 아이폰/아이팟 터치를 테스트 기기로 등록을 할 수 있습니다. Xcode를 이용해 이 등록된 기기로 어플리케이션을 업로드 하여, 실제로 동작을 테스트 해 볼 수 있습니다.

가입이 완료된 후에는 아이폰 개발자 프로그램 포탈에서 iPhone Developer Program Portal User Guide란 문서를 참조하시면, 추후 등록과정을 쉽게 진행하실 수 있습니다. 아이폰 개발자 프로그램 등록 완료란 포스팅에 등록에 관한 저의 간단한 후기가 있습니다.

* 아이폰 개발자 포럼
개발자 프로그램에 등록하시면 현제 베타로 운영중인 아이폰 개발자 포럼도 이용할 수 있습니다. 아이폰 개발자 포럼은 전세계 아이폰 개발자들의 커뮤니티로 주제별로 다양한 의견을 나누고 질문 또는 답변을 할 수 있습니다. 현재까지는 아이폰 개발과 관련되어 질문을 하고 궁굼한 내용을 검색을 하기에 가장 좋은 곳으로 생각이 됩니다.


아이폰 개발에 필요한 소프트웨어를 간단히 알아 보겠습니다. 다음 포스팅에서는 개발을 위해 필요한 정보, 자료등과 접근하는 방법에 대해서 알아 보겠습니다.


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

댓글을 달아 주세요

아이폰어플정보2010. 6. 21. 18:28
iPhone 3Gs에 심카드 넣기

호주에서 입양한 iPhoone 3Gs에 KT/SKT 심카드를 넣어봤습니다.

일단, 심카드에 저장되어 있는 전화번호는 바로 읽히더군요 (모자이크 처리됨). 

다음은 이통사 설정화면입니다.

SKT용 심카드를 넣었을 때의 스샷입니다만, SKT와 KTF가 동시에 뜨더군요.

그동안 아이폰 출시가 KT와 SKT 양쪽에서 고려중이라는 신문 기사들이 전혀

근거없는 것은 아니구나... 라는 생각도 들었다가,

단순히 로밍 때문에 모든 이통사의 데이터베이스가 들어있는건가... 라는 생각도 들었다가,

과연 출시는 되는건가... 이런 저런 생각들을 하고 있는데

결국 연결은 되지 않았습니다. ㅠ_ㅠ

현재로서는 다른 나라에서 iPhone 3Gs를 사 오셔도

국내에서 전화기로 쓸 수 있는 방법은 없어 보입니다.

언제쯤 아이폰을 자유롭게 쓸 수 있을지 참 답답하네요.

펑펜 `>~

================================

바닐라브리즈의 어플을 만나보세요!

================================



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

댓글을 달아 주세요

아이폰어플개발정보2010. 6. 21. 09:29
iPhone 사운드 관련 API
System Sound Services
  경고음이나 인터페이스의 반응음(비프음)등의 짧은 사운드의 재생에 특화된 API이다. 
  볼륨을 바꾸거나 하는 재생 컨트롤은 할수 없다.  바이브레이션도 이 API를 사용한다.(아이폰만 가능)

  관련 프레임워크 : AudioToolbox.framework
  헤더 : AudioToolbox/AudioServices.h

Audio Queue Services
  iPhone OS의 사운드 API의 핵심이다. 사운드파일을 단순히 재생하는 것만이 아니라
  볼륨을 바꾸거나 일부를 루프시키거나 하는 구조를 만들수 있다.
  또, 콜백함수를 쓸 때, 음을 합성하는 신디사이저나 딜레이 같은 이펙트를 만들거나 재생 스피드를
  컨트롤 하는 것도 가능하다. 마이크를 사용한 녹음도 이 API를 사용해 구현하고 있다.
  다만, 구현이 전체적으로 복잡하고, 능숙하게 사용하는데에는 시간이 걸린다.

  관련 프레임워크 : AudioToolbox.framework
  헤더 : AudioToolbox/AudioQueue.h

OpenAL
  OpenAL(Open Audio Library)는 3차원음향용의 인터페이스이다. 음원을 3차원공간 내에 배치시켜
  움직이는 것이 가능하다. 3차원 그랙픽의 OpenGL과 같다. 표준적인 인터페이스로서 플렛폼을 불문하고,
  여러가지 플렛폼에 설치되어 있다. 3D게임 등에 이용이 많으나, 음을 울리는 것만이면 비교적 구현이
  간단한 이점이 있다. 루프나 볼륨의 컨트롤 등도 가능하므로, System Sound Services와 Audio Queue Services
  의 중간적인 기능을 가진 구조로서 이용하는 것이 가능하다.
  또, 재생의 대기시간도 적으므로 실시간성이 요구되는 어플리케이션용이라고 할수 있다.

  관련 프레임워크 : OpenAL.framework
  헤더 : OpenAL/al.h OpenAL/alc.h

AVAudioPlayer (iPhone OS 2.2~)
  iPhone OS 2.2부터 도입된 방법이다. 사운드를 재생하는 것만에 Audio Queue Services 등을 사용하는 것은
  복잡하다는 개발자의 소리에 의해, 사운드파일의 재생만을 특화한 API로서 도입되었다. 볼륨이나 루프의
  설정도 가능하다. Audio Queue Services과 같이 자유도와 확장성은 없으나, 간단히 사용할수 있다.

  관련 프레임워크 : AVFoundation.framework
  헤더 : AVFoundation/AVAudioPlayer.h

Audio Unit
  가장 하드웨어에 가까운 낮은 레벨의 방법이다. 다른 API는 전부 시스템 위에 구축되어 있다.
  이펙트 등의 고도의 처리를 적은 대기시간으로 구현하고 싶을 때에 사용할 수 있다.
  다만, 구현은 상당히 복잡하다.

  관련 프레임워크 : AudioUnit.framework
  헤더 : AudioUnit/AudioUnit.h

[출처 : ユメみるiPhone]

어디에 이 글을 올려야 될지 한참 고민했네요.. 
단지 되는대로 해석해 놓아서 좀 어색한 부분이 있을 수 있으나 넓은 아량과 높은 이해도로 커버해 주세요^^
 


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

댓글을 달아 주세요

아이폰어플개발정보2010. 6. 20. 23:17
iPhone 개발 환경

iPhone 개발은 애플에서 제공하는 iPhone 개발환경을 이용해서 개발을 진행할 수 있다. 애플의 개발환경은 Mac OS X에서만 동작하므로 맥이 필요하다.

iPhone 개발환경을 위해서는 먼저 ADC(Apple Developer Connection)의 회원이어야 하며 iPhone Developer로 따로 가입해야 한다. 개발환경을 위한 회원가입은 무료이므로 누구나 쉽게 가입할 수 있다.

개발환경에는 아이폰 시뮬레이션 개발 환경을 제공하고 있는데 이것을 이용해서 개발은 진행할 수 있다. 하지만 실제 동작을 테스트하기 위해서는 실제 디바이스(iPhone 또는 iPod Touch)를 이용해서 진행해야 하는데 아이폰 시뮬레이션 개발환경에서는 메모리나 CPU 성능과 관련해서는 직접 테스트를 하기 힘들기 때문이다.

실제 iPhone 디바이스에 개발한 프로그램을 올려서 사용하기 위해서는 애플의 iPhone Development Program에 등록을 해야 한다.

http://developer.apple.com/iphone/program

99$와 299$ 두가지의 프로그램이 있는데 각각에 맞는 것을 선택해서 가입하면 된다.

프로그램에 가입하면 디바이스에 어플리케이션을 올려서 테스트할 수 있도록 CSR(Certificate Signing Request), Development certificate, Provisioning profile이 생성되게 된다.

보다 자세한 사항에 대해서는 다음에 따로 설명하겠다.



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

댓글을 달아 주세요

아이폰어플개발정보2010. 6. 20. 23:17
iPhone Software Stack

iPhone의 개발 API 스텍은 크게 Core OS, Core Services, Media, Cocoa Touch의 네 개의 계층으로 구성
 


Cocoa Touch
기존 맥 오에스의 UI 프레임워크인 Cocoa의 iPhone용 버전
크게 두가지의 프레임워크로 구성
 - UIKit 프레임워크(UIKit.framework)와 Foundation 프레임워크(foundation.framework)
제공 기능
 - 어플리케이션 관리
 - 그래픽 및 윈도우 지원(UI Framework : Windows, UI 관리)
 - 이벤트 핸들링 지원
 - 표준 시스템 컨트롤과 뷰의 객체 표시
 - Accelerometer 데이터(x, y ,z 축으로 아이폰의 움직임 감지)
 - 멀티 터치 인터페이스(Multi-Touch interface)
 - Built-in 카메라
 - 사용자 사진 라이브러리(User's photo library)
 - 장치에 관련된 정보

Media
오디오,비디오, 그래픽, 애니메이션 등의 멀티미디어 환경 구현을 위한 라이브러리 계층

그래픽 : 2D와 3D
 - OpenGL ES(OpenGLES.framework, EAGL.framework)
 - Quartz(QuartzCore.framework)
 - Core Animation(Core-Graphics.framework)

사운드
 - Core Audio(CoreAudio.framework) : 오디오 타입과 파일 정보
 - OpenAL(크로스 플랫폼을 지원하는 표준 3D 사운드 라이브러리)
 - 오디오 믹싱과 재생/녹화(AudioToolbox.framework)
 - 오디오 처리(AudioUnit.framework)

비디오 : .mov, .mp4, .m4v, and .3gp 파일 지원
 - 풀 화면 비디오 재생(MediaPlayer.framework)
 
Core Service
모든 어플리세이션들이 사용하는 OS에서 제공하는 기본 기본을 더 편리하게 사용할 수 있는 라이브러리들을 제공
 - 주소록 접속(AddressBook.framework, AddressBookUI.framework)
 - Core Location(CoreLocation.framework) : 장치의 현재의 위도(latitude/longitude), 기지국 정보를 이용한 아이폰의 위치정보를 제공
 - CFNetwork(CFNetwork.framework) : socket, SSL, DNS, HTTP, FTP, Bonjour
 - 보안(Security.framework) : Certificate, public/private keys
 - Embedded SQLite database : SQLite의 DB 기능
 - XML Library

Core OS
기본적으로 맥 노트북이나 데스크탑 용 OS와 동일한 라이브러리(LibSystem)들을 제공
커널 환경, 디바이스 드라이버, C 인터페이스
 - Threading (POSIX 쓰레드)

 - 네트워킹 (BSD 소켓)
 - File-system access
 - Standard I/O
 - Bonjour와 DNS 서비스
 - Locale information
 - Memory allocation



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

댓글을 달아 주세요

아이폰어플개발정보2010. 6. 20. 23:17
스탠포드 대학 iPhone 강의

스탠포드 대학에서 iPhone 개발 과정을 진행하고 있다.

iTunes를 사용해서 강의를 수강할 수 있는데 예전과 다르게 모든 이들에게 오픈되어 있는 것 같다.

현재 강의가 진행 중인데 3강까지 진행되었다.

http://www.stanford.edu/class/cs193p/cgi-bin/index.php

전체 일정은 아래와 같다.

Week 1 — 4/1
4/1: Intro to Mac OS X and Cocoa Touch, Objective-C and Dev Tools
Assignment: Hello Stanford and Command Line Tool I (due 4/9)
Week 2 — 4/6 & 4/8
4/6: Using Objective-C, Foundation framework
4/8: Custom classes, Memory Management, ObjC Properties
Assignment: Command Line Tool II and HelloPoly I (due 4/14)
Week 3 — 4/13 & 4/15
4/13: Interface Builder, Controls, Target-Action
4/15: Views and Drawing, Animations
Assignment: HelloPoly II (due 4/21)
Week 4 — 4/20 & 4/22
4/20: View Controller Basics
4/22: Navigation Controllers
Assignment: Presence 1 (due 4/28)
Week 5 — 4/27 & 4/29
4/27: Table Views
4/29: Dealing with Data: User Defaults, SQLite, Web Services
Assignment: Presence 2 (due 5/5), Final project proposals
Week 6 — 5/4 & 5/6
5/4: Threading, Caching and Memory
5/6: Text Input, Responder Chain, Presenting Content Modally
Assignment: Presence 3 (due 5/12)
Week 7 — 5/11 & 5/13
5/11: Address Book
5/13: Searching, Notifications
Assignment: Presence 4 (due 5/19)
Week 8 — 5/18 & 5/20
5/18: Multitouch
5/20: Device APIS: Image Picker, Core Location, Accelerometer, Battery Life
Assignment: Final project (due week of 6/8, exact date TBD)
Week 9 — 5/27
5/25: Memorial Day Holiday, no classes

그리고 예제와 관련해서 아래 사이트도 참고할만하다.

http://www.appsamuck.com/



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

댓글을 달아 주세요

아이폰어플개발정보2010. 6. 17. 17:51
[펌] iPhone 어플리케이션의 실행 구조

[출처: http://maclove.pe.kr/25]

어플리케이션이 처음 실행되고 부터 종료될 때 까지의 흐름을 살펴보도록 하겠다. 맥이나 윈도우 모두 그래픽 기반의 운영체제이다. 그래픽 기반의 운영체제에서 어플리케이션을 구현시키는 가장 좋은 방식은 이벤트 드리븐(Event driven)이다. 이벤트는 사용자가 마우스나 키보드를 누르는 것부터 특정 시간이 지났다는 이벤트, 네트워크로 데이터를 받았다는 이벤트 등등 모든 것이 해당할 수 있다. 놀랍게도 세계에서 가장 발전한 상용 GUI OS들인 맥 OS , MS의 윈도우즈 들의 아름다운 UI 밑에는 가장 기본적인 뼈대 Main Loop이 버티고 있다. 사실 컴퓨터 소프트웨어가 하는 일은 최초의 컴퓨터가 발명된 때와 별반 다르지 않다. 그 위에 수만 겹의 추상화가 지금의 컴퓨팅 환경을 만들어 놓았지만, 그 뼈대는 변하지 않은 것이다. 컴퓨터는 여전히 0 과 1밖에 모르는 바보다. 크게 어렵지 않으니 하나하나 익혀나가면서 정복해 보자.

* 처음 시작

사용자가 스프링 보드에 있는 어플리케이션의 아이콘을 누르면 어플리케이션이 실행된다. 다음 코드를 보자.

1.int main(int argc, char *argv[]) {
2.     
3.    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
4.    int retVal = UIApplicationMain(argc, argv, nil, nil);
5.    [pool release];
6.    return retVal;
7.}



Xcode 에서 자동으로 생성해 주는 코드이다. 기존의 C 함수와 마찬가지로 아이폰OS 에서 실행되는 프로그램들도 시작점은 메인 함수 이다. 메인 함수는 가장 먼저 자동해제 풀을 하나 할당한다. 자동해제 풀이란 메모리를 자동 릴리즈 하겠다고 설정한 객체들을 임시로 보관해 두었다가 적절한 시점에 해제시키기 위한 저장공간 정도로 이해하고 넘어가자.

다음 코드는 UIApplicationMain 함수를 실행시킨다. 이 함수는 argc, argv 이외에 두 개의 중요한 인자를 받는다. 첫번째로 UIApplication 클래스의 이름을 전달받는다. nil 을 입력하는 경우는 기본값인 UIApplication이 사용된다. 만약 UIApplication 을 상속받아서 새로운 클래스를 만들었다면 그 이름을 넣어주도록 하자.  두번째는 어플리케이션 델리게이트의 이름을 입력하며, nil 일 경우 info.plist 에 정의된 NSMainNibFile이 가리키는 nib파일에 설정되어 있는 델리게이트를 이용한다. 




<그림> 어플리케이션 흐름

그림을 통해서 흐름을 이해하도록 하자. 최초 main 이 호출되고 UIApplictionMain 이라는 함수 안에서 UIApplication 클래스가 하나 만들어 진다. 이 클래스는 UIKit8 에서 미리 구현해 놓은 것으로 어플리케이션 자체를 의미하는 클래스이며 한 어플리케션에 오직 하나의 UIApplication 클래스를 가지고 있다. pInfo.list 에서 UIApplication이 사용할 메인 nib 파일을 지정했다면(NSMainNibFile) 이 nib 파일을 읽어들인다. UIKit 프레임 워크는 이 파일을 분석해서 내부에 포함되어있는 객체들을 생성하고 초기화 시킨다. 보통 UIWindow 객체와 UIView 객체 등이 생성될 것이다. 그리고 인터페이스 빌더에서 설정했던 델리게이트나 객체 간의 연결도 설정한다. 이 작업이 완료되면 연결된 델리게이트의 applicationDidFinishLaunching 이 불려진다. 만약 nib 파일이 없는 경우 즉 NSMainNibFile을 설정하지 않은 경우에는 델리게이트의 applicationDidFinishLaunching 가 호출될 때 화면에 보여줄 객체들을 수동으로 만들어 줘야 한다.

그 이후 부터 UIApplication 에서는 이벤트를 처리하기 위한 메인 루프가 실행된다. 사용자가 홈 버튼을 누르거나, 전화를 받는 등의 이벤트에 의해서 어플리케이션이 종료된다. 이 때는 applicationWillTerminate 메시지가 불려지고, 이곳에서 어플리케이션의 상태를 저장하는 등의 작업을 해야 한다.

UIApplicationDelegate 는 지금 설명한 것 외에도 중요한 이벤트가 발생한 경우 그에 맞는 처리를 할 수 있는 다음 메서드들도 있다.

applicationDidReceiveMemoryWarning
메모리 부족 경고를 받은 경우. 현재 사용중인 메모리를 최대한 해제해야 한다.
applicationWillResignActive
어플리케이션이 실행중일 때 전화가 오면, 전화를 받을 것인지 무시할 지를 선택할 수 있다. 그 전에 이 메서드가 호출될 것이다. 또한 화면 잠금 버튼을 누른 경우에도 호출된다.
applicationDidBecomeActive
사용자가 전화나, 문자 등을 무시하는 버튼을 선택할 경우 다시 어플리케이션이 활성화 된 것을 알 수 있다. 처음 실행될 때 applicationDidFinishLaunching 메시지가 보내진 이 후에도 호출되고, 잠금 상태에서 다시 해제된 경우도 호출된다.
application:didFinishLaunchingWithOptions
아이폰 OS 3.0에 추가된 것으로 URL 이나 원격 통보(Remote notification) 에 의해서 어플리케이션이 실행된 경우를 처리할 수 있다.
application:didReceiveRemoteNotification
역시 3.0에 추가된 것으로 프로그램이 실행중에 원격 통보(Remote notification)을 받은 경우 필요한 처리를 할 수있다.

[출처: http://maclove.pe.kr/25]





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

댓글을 달아 주세요

«이전  1 ··· 4 5 6 7  다음»