Untitled @scrambled-code - Tumblr Blog

UIViewController lifecycle

http://stackoverflow.com/questions/5107604/can-somebody-explain-the-process-of-a-uiviewcontroller-birth-which-method-follo

From http://stackoverflow.com/questions/6757018/why-am-i-having-to-manually-set-my-views-frame-in-viewdidload

It helps to understand what happens when a view controller's view is loaded and displayed:

Something accesses your view controller's view property for the first time. This may occur in your own code, or in UIKit in response to a user action like selecting a tab.

UIKit lazy-loads your view controller's view by calling loadView if it's defined, or by loading the view from the NIB that was specified in initWithNibName:bundle:. If neither exists, UIKit just loads an empty view.

UIKit calls viewDidLoad once the view and its subviews have been fully loaded. At this point the view's frame will be whatever it was set to in the NIB, or in loadView.

Something calls for UIKit to display your view controller's view. Again, this may be a user action like tapping on a tab, or an explicit method call in your code like pushViewController:animated: orpresentModalViewController:animated:.

UIKit resizes the view based on the context in which it will be presented, as described above.

UIKit calls viewWillAppear:. The frame should now be the size that will be displayed.

UIKit displays the view, with or without animations.

UIKit calls viewDidAppear:.

Custom controls

http://www.objc.io/issue-3/custom-controls.html

Now, let’s move on to the visual bit: custom rendering. As Daniel mentioned in his article, you probably want to avoid doing rendering on the CPU, but instead offload it to the GPU. There is one rule of thumb to achieve this: try to avoid drawRect:, and instead compose your custom views out of existing views.

I would like to encourage you to dive into CALayer and its properties, because most of what you can achieve with that will be faster than drawing your own things using Core Graphics. Nonetheless, as always, it is important to profile your code.

CUSTOM DRAWING

If you do decide to do custom drawing, there are several different options you can choose from. If possible, see if you can generate an image, and then cache that, either on disk or in memory. If your content is very dynamic, you can maybe use Core Animation, or if it doesn’t work, go for Core Graphics. If you really want to get close to the metal, it is not that hard to use GLKit and raw OpenGL, but it does require a lot of work.

If you do choose to override drawRect:, make sure to take a look at content modes. The default mode scales the content to fill the view’s bounds, and does not get redrawn when the frame changes.

CUSTOM INTERACTION

As said, when writing custom controls, you almost always want to extend a subclass of UIControl. In your subclass, you can fire events using the target action mechanism, as shown in this example:

[self sendActionsForControlEvents:UIControlEventValueChanged];

To respond to touches, you almost always want to use gesture recognizers. However, if you want to go low-level, you can still override the methods touchesBegan,touchesMoved, and touchesEnded to get access to the raw touches. That said, to separate the gesture handling from your custom view or view controller, it is almost always more appropriate to create a gesture recognizer subclass.

UIButton

http://robots.thoughtbot.com/designing-for-ios-taming-uibutton

[More]

Event propagation and Responder Chain

https://developer.apple.com/library/ios/documentation/EventHandling/Conceptual/EventHandlingiPhoneOS/event_delivery_responder_chain/event_delivery_responder_chain.html#//apple_ref/doc/uid/TP40009541-CH4-SW2

UIView and CALayer

from (http://stablekernel.com/blog/view-controller-lifecycle-in-ios6/):

UIView is a subclass of UIResponder (so that it can receive events) and has a pointer to its own CALayer instance (so that it can be drawn on the screen).

A CALayer is a container for a bitmap image. When a UIView runs its drawRect: method, it is creating the bitmap image for its layer. The rest of a layer’s instance variables (many of which it borrows from its UIView, like its frame and backgroundColor) indicate how and where that bitmap image is composited onto the screen.

But the biggest part of the layer (in terms of memory usage) is that bitmap. A layer itself is only 48 bytes and a standard UIView is only 96 bytes, regardless of their size on the screen. The memory consumption for a layer’s bitmap, however, grows very large depending on the bounds of the layer. For example, a full screen retina-display iPad view can be up to a whopping 12 megabytes.

UIViewController lifecycle (iOS 6)

http://stablekernel.com/blog/view-controller-lifecycle-in-ios6/

define vs const

http://stablekernel.com/blog/define-vs-const-vs-the-world/

coding your cell phone like a server is wrong

http://highscalability.com/blog/2013/9/18/if-youre-programming-a-cell-phone-like-a-server-youre-doing.html

delegation vs blocks

http://stablekernel.com/blog/blocks-or-delegation/

Asserts

From Mike Ash in http://www.mikeash.com/pyblog/friday-qa-2013-05-03-proper-use-of-asserts.html

Fundamentally, an assert is just a call that takes an expression and indicates failure in some way if the expression isn't true. The basic idea is to check for conditions that should always be true so that you fail early and obviously, rather than failing later and confusingly. For example, an array dereference will fail in various weird ways if you give it a bad index:

x = array[index]; // sure hope index is in range

Using an assert can help make it obvious what went wrong:

assert(index >= 0 && index < arrayLength); x = array[index];

NSInteger - use it

You usually want to use NSInteger when you don't know what kind of processor architecture your code might run on, so you may for some reason want the largest possible int type, which on 32 bit systems is just an int, while on a 64-bit system it's a long.

I'd stick with using NSInteger instead of int/long unless you specifically require them.

NSInteger/NSUInteger are defined as *dynamic typedef*s to one of these types, and they are defined like this:

#if __LP64__ || TARGET_OS_EMBEDDED || TARGET_OS_IPHONE || TARGET_OS_WIN32 || NS_BUILD_32_LIKE_64 typedef long NSInteger; typedef unsigned long NSUInteger; #else typedef int NSInteger; typedef unsigned int NSUInteger; #endif

#ios #cocoa #nsinteger #coding #bestpractices

Accessing self in init or dealloc

Imagine you're accessing self to set one of your properties in your constructor, e.g. init. If that property's setter uses any state from self, it may not have been completely set. Same happens for dealloc.

#cocoa #coding #ios #bestpractices #memorymanagement

Enums in Objective-c

From Matt Thomson's post on NSHipster:

Apple had previously defined all of their enum types as:

typedef enum { UITableViewCellStyleDefault, UITableViewCellStyleValue1, UITableViewCellStyleValue2, UITableViewCellStyleSubtitle }; typedef NSInteger UITableViewCellStyle;

Oh, im so stupid.

So that's how they managed to get the intellisense thing working on enums. The method implementation expects a NSInteger, but since we have a type called UITableViewCellStyle as a typedef of NSInteger, the method signature receives a UITableViewCellStyle.

This way, when the user is sending the message, the intellisense suggests all the UITableViewCellStyle-prefixed enum values.

If you'd like to use either macro when targeting a previous version of iOS or OS X, you can simply inline like so:

#ifndef NS_ENUM #define NS_ENUM(_type, _name) enum _name : _type _name; enum _name : _type #endif

So, after iOS 6, the best way to do it is:

Now, UITableViewCellStyle is declared with:

typedef NS_ENUM(NSInteger, UITableViewCellStyle) { UITableViewCellStyleDefault, UITableViewCellStyleValue1, UITableViewCellStyleValue2, UITableViewCellStyleSubtitle };

The first argument for NS_ENUM is the type used to store the new type. In a 64-bit environment,UITableViewCellStyle will be 8 bytes long--same as NSInteger. Make sure that the specified size can fit all of the defined values, or else an error will be generated. The second argument is the name of the new type (as you probably guessed). Inside the block, the values are defined as usual.

Do not forget NS_OPTIONS when looking for bitmasks.

#objective-c #cocoa #ios #coding #xcode #enum #intellisense

Date in Cocoa

http://oleb.net/blog/2011/11/working-with-date-and-time-in-cocoa-part-2/

Consider NSDataDetector

node.js simple and clear

"Well, in node everything runs in parallel, except your code."

Nice post from Felix Geisendorfer.

Note: node.js uses confinement as a way to solve concurrency problems, i.e only one thread at a time accesses the data structures.

#nodejs

UIView animateWithDuration:animations:completion:

The completion block receives a boolean parameter that tells you if the animation ran till the end or if it ended sooner. This might happen if you specified an excessively high value for duration or if the animation is competing with others in the same view hierarchy.

#ios #coding #objective-c #cocoa #animations #iphone

Split git commit into smaller ones

a) git branch splitme 64d1dc9 where 64d1dc9 is the commit that you want to split

b) git rebase -i splitme~1 Where splitme~1 points to the parent of the commit that you want to split. This is to be able to edit the commit and check a part of it to rebase. Then we'll commit it. This way we get a smaller commit. Then we do the same thing for other parts of the big commit.

On the editor i changed "pick" for "edit" on the commit that i want to split. On the other one(s) let it stay with "pick".

c) Now we get back to the shell and perform changes to the commit. In this case we RESET to HEAD all the files that we do not want to commit. This way we only keep the ones to be included in this new smaller commit.

For instance: git show --name-only

And now do: git reset head~1 <file1> <file2> where you choose to reset the changes done to file1 and file2 on that commit. This way you keep the ones you want to include in the new smaller commit.

git commit -m "Message for smaller commit" --amend Here we use --amend because we want to change the commit. On the next ones we won't do it, because they'll be new ones.

d) Do the same for the rest of the smaller commits that you want to perform.

git checkout splitme . If at this point you do "git branch" you'll stand on (no branch). Because you're in the middle of a rebase, i guess.

e) git rebase --continue Go through the rest of the lines edited in "git rebase i".

f) git branch -D splitme Delete bookmark.

Git useful commands

git diff --name-only $BRANCH

git rm --cached -r $FILES

git RESET HEAD^x or HEAD~x (^is a continuation character in DOS)

git show-branch $BRANCH

git show --name-only 34592f4

Split commit in several -> look for post here.

git stash save "bla"

git stash pop

git reflog Specially useful to undo a git reset. You can run git reset <x>, where <x> is the place to where you want to go in the reflog.

git clean -f -d Removes untracked files.

git checkout --patch <branch> <file> Bring changes from a specific file of a specific branch.

git add -p <file> Select which parts of the file you want to add.

[To be continued]

Trending Blogs

Recently Viewed Blogs

Untitled