IOS codes

iOS 5 : Customize UINavigationBar and UIBarButtonItem with the Appearance API

2013-01-08T23:30:00.002-08:00

Change UINavigationBar Background

With the release of iOS 5, the UIAppearance protocol is used to access the appearance proxy for a class you would like to configure. Customization is done by sending messages to the target class appearance proxy. When changing the appearance of an object, all instances of the object can be updated or only specific instances within a container class.

Let’s see how this looks as it relates to updating the background color of a UINavigationBar, it’s text and the back button which will allow a user to return to a previous view controller.

The image below is the gradient that I will use for the background:

Using the above image, I created a one pixel wide image for both portrait and landscape variations of the navbar, reason being, the height of the navar bar when the device is in portrait mode is 44, whereas the height for landscape is 32.

The images in my project are NavigationPortraitBackground.png and NavigationLandscapeBackground.png, both shown below:

I now create two UIImage objects:

// Create image for navigation background - portrait
UIImage *NavigationPortraitBackground = [[UIImage imageNamed:@"NavigationPortraitBackground"] 
                              resizableImageWithCapInsets:UIEdgeInsetsMake(0, 0, 0, 0)];
 
// Create image for navigation background - landscape
UIImage *NavigationLandscapeBackground = [[UIImage imageNamed:@"NavigationLandscapeBackground"] 
                              resizableImageWithCapInsets:UIEdgeInsetsMake(0, 0, 0, 0)];

To set these images as the new backgrounds for all navigation bars, here’s all I need to do:

// Set the background image all UINavigationBars
[[UINavigationBar appearance] setBackgroundImage:NavigationPortraitBackground 
                                     forBarMetrics:UIBarMetricsDefault];
[[UINavigationBar appearance] setBackgroundImage:NavigationLandscapeBackground 
                                     forBarMetrics:UIBarMetricsLandscapePhone];

In addition to the color, I can change the appearance of the text on all navigations bars as well:

// Set the text appearance for navbar
[[UINavigationBar appearance] setTitleTextAttributes:
    [NSDictionary dictionaryWithObjectsAndKeys:
    [UIColor whiteColor], UITextAttributeTextColor, 
    [UIColor redColor], UITextAttributeTextShadowColor, 
    [NSValue valueWithUIOffset:UIOffsetMake(0, 0)], UITextAttributeTextShadowOffset, 
    [UIFont fontWithName:@"Verdana-Bold" size:16], UITextAttributeFont, 
    nil]];

As the final step, I will update the back button with a custom image, which is shown below (the button is shown on a gray backdrop so you can see the white border):

Using what I described in the early post about cap insets, I can create a UIImage object and use the appearance API of the UIBarButtonItem to set the back button look. Notice that each value in the cap inset is set to 12, indicating all four corners are to hold steady at 12 pixels, even if the images stretched or resized.

// Set back button for navbar
UIImage *backButton = [[UIImage imageNamed:@"blueButton"]  resizableImageWithCapInsets:UIEdgeInsetsMake(12, 12, 12, 12)];
  [[UIBarButtonItem appearance] setBackButtonBackgroundImage:backButton forState:UIControlStateNormal barMetrics:UIBarMetricsDefault];

The last step is to create a button for the user interface that will push a new view controller, which will update the navigation bar to show the custom back button created above.

...
 
testButton = [[UIButton alloc] initWithFrame:CGRectMake(80, 30, 160, 44)];  
[testButton setTitle:@"Test Button" forState:UIControlStateNormal];
 
// Notice cap insets are different from above
UIImage *buttonImage = [[UIImage imageNamed:@"blueButton"]  resizableImageWithCapInsets:UIEdgeInsetsMake(0, 16, 0, 16)];
 
[testButton addTarget:self action:@selector(buttonPressed:) forControlEvents: UIControlEventTouchUpInside];        
[testButton setBackgroundImage:buttonImage forState:UIControlStateNormal];
 
...

An important concept to understand here, I’ve used the same image, blueButton.png, for both the custom back button as well as the button on the primary user interface – setting the cap insets specifies the rules, if you will, of how the image can be stretched, yet keep the look appropriate for the context in which the button will appear (that is, on the navbar or main UI).

A few screenshots follow that show the custom navigation bar, text and buttons in both portrait and landscape modes:

i copied this post from this link

http://mobiledevelopertips.com/user-interface/ios-5-customize-uinavigationbar-and-uibarbuttonitem-with-appearance-api.html#comment-109364

shouldAutorotateToInterfaceOrientation not getting called in iOS 6

2012-10-01T04:16:00.001-07:00

The shouldAutorotateToInterfaceOrientation method is deprecated in iOS6. Instead shouldAutorotate and supportedInterfaceOrientation methods are used. If some logic is used in shouldAutorotateToInterfaceOrientation method, it should be implemented in -willRotateToInterfaceOrientation:duration: method.

First, if you want the view controller’s content to be able to auto rotate just return YES in -shouldAutorotate method.

- (BOOL)shouldAutorotate
{
 return YES;
}

Supported interface orientations are returned in the -supportedInterfaceOrientations method.

- (NSUInteger)supportedInterfaceOrientations
{
        //if you have different views for portrait and landscape they are assigned here for the first time
 self.view = UIInterfaceOrientationIsLandscape([[UIApplication sharedApplication] statusBarOrientation]) ? _viewLandscape : _viewPortrait;
        //return orientations you want to support
 return (UIInterfaceOrientationMaskPortrait | UIInterfaceOrientationMaskLandscapeLeft | UIInterfaceOrientationMaskLandscapeRight | UIInterfaceOrientationMaskPortraitUpsideDown);
}


f there is some logic, like switching views for landscape and portrait on rotation use the -willRotateToInterfaceOrientation:duration: method.


- (void)willRotateToInterfaceOrientation:(UIInterfaceOrientation)toInterfaceOrientation duration:(NSTimeInterval)duration
{
 [super willRotateToInterfaceOrientation:toInterfaceOrientation duration:duration];
 self.view = UIInterfaceOrientationIsLandscape(toInterfaceOrientation) ? _viewLandscape : _viewPortrait;
}

How to get the attributes of an instance of NSTableView

2012-09-28T02:11:00.002-07:00

How to get the attributes of an instance of NSTableView

The table view object (in MacOSx) is a collection of nested objects :

NSScrollView,
NSTableView,
NSTableColumn

To get to a ojbect in this collection,

hold down the Control and Shift keys, while clicking on the table view.

You will see a list of the objects under the cursor, and you can select the object you're interested in.

How can you suppress compilers warning "can't find an implementation of accessor methods"

2012-09-28T02:09:00.004-07:00

How can you suppress compilers warning "can't find an implementation of accessor methods"

#:fromDocumentation

You use the @dynamic statement to tell the compiler to suppress a warning if it can’t find an implementation of accessor methods specified by an @property declaration.

@implementation MyClass

@dynamic title;

@end

A summary of property-properties attributes - and some tips

2012-09-28T02:09:00.001-07:00

A summary of property-properties attributes - and some tips

@Property attributes

Writability

readwrite

mutually exclusive

default

Indicates that the property should be treated as read/write

readonly

only a getter method is required

if you attempt to assign a value using the dot syntax, you get a compiler error.

A readonly property can redelcare it as readwrite in a class extension, a protocol or in a subclass.

Setter

Semantics

assign (iOS 5)

unsafe_unretain (iOS4)

default

setter uses simple assignment (new value not retained, old value is not released).

use this for scalar types (NSInteger, CGRect in Ref.Counted env.

on dealloc method make sure that object propertis marked assign are not released and the not assign are released.

property=newValue;

retain

strong

if (property!=newValue){

[property release];

property = [newValue retain];

retain should be invoked on the object upon assignment

the previous value is sent a release message

valid only for Objective-C object types (no for Core Foundation)

_attribute_

use attribute keyword to specify that a Core foundation property should be treated like an Objective C for memory management

copy

if (property!=newValue){

[property release];

property = [newValue copy];

}

a copy of the object should be used for assignment

previus value is sent a release message

valid only for objects that implement the NSCopying protocol

WARNING-the copy method returns an immutable version of a collection, so if you want a mutable version you need to implement the setter rather to synthesize it.

Atomicity

nonatomic

Specify that accessor methods are not atomic

(by default accessors are atomic=robust access to properties in a multithreaded environment)

If you specity retain or copy with not the noatomic, then in a reference-counted environment, a synthesized get accessor for an object property uses a lock and retains and autoreleases the returned value (similar to code below nonatomic)

[_internal lock]; //lock

id result = [[value retain] autorelease];

[_internal unlock];

return result;

Interface Outlet

IBOutlet

To specify that a property is an Interface Builder oulet

@property (nonatomic, retain) IBOutlet NSButton *myButton;

when you see __Blabla is for instance variables and Blabla is for property attribute.
For declared properties, you should use assign instead of weak; for variables you should use __unsafe_unretained instead of __weak.
You will always use unsafe_unretained for properties that hold non-objects.
For properties that hold objects, you will usually use strong
unsafe_unretained will have a "dangling pointer" if the object it points to is deallocated.
Their most common use is for delegates, where you'd define a property for that delegate with the weak orunsafe_unretained attribute (assign is effectively unsafe_unretained),
copy attribute is most common with object types that have mutable subclasses.
copy method returns an immutable copy.
Curiously the copy and mutableCopy methods are define in NSObject like this:

-(id) copy {return [self copyWithZone:NULL];}

-(id) mutableCopy {return [self mutableCopyWithZone:NULL];}

So you need to be carefully in your custom objects (you need to override the copyWithZone etc).

nonatomic option will make your setter method run a tiny bit faster.

TIP_1:
For iOS 5.0-Lion use __weak. For iOS4.0-Snow Leopard use __unsafe_unretained. Why?

As its name implies, __unsafe_unretained will continue pointing to the memory where an object was, even after it was deallocated. This can lead to crashes due to accessing that deallocated object.

Why would you ever use __unsafe_unretained then? Unfortunately, __weak is only supported for iOS 5.0 and Lion as deployment targets. If you want to target back to iOS 4.0 and Snow Leopard, you have to use the __unsafe_unretained qualifier.

TIP_2:
Do you know that when compiling for iOS or a 64-bit Mac OS X (not for 32-bit Mac OSX) program, you don't need to declare the instance variables?
The @property/@ synthesize calls are sufficient to make the space for the data.
(from The big nerd ranch Guide)

Retain Cycle

2012-09-28T02:08:00.000-07:00

Retain Cycle

Retain cycles are a very common source of memory leaks.

We have retain cycles when :
The object A has strong ownership on object B (direct or indirect) and the B has, also strong ownership at A.

That happens for example if the A has an MutableArray of objects B and some from objects B have strong ownership on object A.

the solution on theses cases is to use strong ownership (retain, alloc, etc) to child objects (B) and the child objects to have weak (__weak) ownership at the father.

Apple provides the Instrument profiling tool to help you with that.
When you profile a program, you monitor it while it runs to see what’s happening behind the scenes.

Xcode ->
Product ->
Profile … (Instruments launch) choose Leaks
-> Choose Cycles to see if your project has some of them.

#:from Objective - C programming: The big Nerd Ranch Guide

Callbacks - short notes

2012-09-28T02:07:00.000-07:00

For Objective-C programmers, there are three-forms that a callback can take.

- TARGET-ACTION: before the wait begins you say “When x happens, send this particular message to that particular object,” The object receiving the message is the target. The selector for the message is the action.
- Helper objects: Before the wait begins, you say “Here is a helper object that conforms to your protocol. Send it messages when things happen”. Helper objects are often known as delegates or data sources.
- Notifications: There is an object called the notification center. Before the wait begins, you say to the notification center “This object is waiting for these sorts of notifications. When one of those notifications arrives, send the object this message”. When x happens, an object posts a notification to the notification center, and the center forwards it on to your object.

Types of Callbacks
Target-Action	sending ONE callback to ONE object	timers,simple user interface controls(buttons, sliders etc)
Helper objects (delegate or data source)	sending MANY callbacks to ONE object	NSURLConnection. The most common type of helper object is the delegate
Notifications	sending MANY callbacks to Multiple object	Notification center

Notes:

- Notification centers do not own their observers (they typically remove itself from notification in its dealloc method)

- Objects do not own their delegates or data sources (if you create an object that is delegate or data source, your object need to “clear” himself in its dealloc method). Exception: NSURLConnection owns its delegate

- Objects do not own their targets. (if you create an object that is a target, your object should zero the target pointer in its dealloc method).Exception: NSTimer owns it’s target.

#:From The Big Nerd Ranch Guide Objective C programming

isa - super - self

2012-09-28T02:05:00.000-07:00

isa - super - self

short notes:

isa

NSObject has many methods, but only one instance variable: the isa pointer.
Every object's isa pointer points back to the class that created it.
We call it the isa pointer because an object "is a " instance of that class. At runtime when a message is sent to an object, that object goes to the class named in its isa pointer and says, "I was sent this message. Run the code for the matching method". This is different than most compiled languages, where the method to be executed is determined at compile time.
The isa pointer, as the name suggests, points to the object's class which maintains a dispatch table. This dispatch table essentially contains pointers to the methods the class implements, among other data.
The value of the isa pointer does not necessarily reflect the actual class of the instance. When an observer is registered for an attribute of an object the isa pointer of the observed object is modified, pointing to an intermediate class rather than at the true class.
You should never rely on the isa pointer to determine class membership. Instead, you should use the class method to determine the class of an object instance.

A little confused from the above i will get back on this ..!?!?!?

super:

To be precise, the super directive says "Run this method, but start the search for its implementation at my superclass".
Each version of init follows this procedure, so classed initialize theri instance variables in the order of inheritance

- (id) init
{
self = [super init];
if (self) {
...
}
}

super is simply a flag to the compiler telling it where to begin searching for the method to perform; it's used only as the receiver of a message. But self is a variable name that can be used in any number of ways, even assigned a new value (see Redefining self)
super is a flag that tells the compiler to search for the method implementation, begins in the superclass of the class that defines the method where super appears.
wherever super receives a message, the compiler substitutes another messaging routine for the objc_msgSend function.

self:

is one of the hidden parameters that the messaging routine passes to every method; it's a local variable that can be used freely within a method implementation, just as the names of instance variables
self searches for the method implementation in the usual manner, starting in the dispatch table of the receiving object's class.

from Big Ned Ranch Guide Object C & ios Programming + Documentation

How we import (constant) global variables and #define VS global variables

2012-09-28T02:04:00.000-07:00

How we import (constant) global variables and #define VS global variables

One of them informs the preprocessor to do a textual substitution. The other actually declares a (constant) C variable.

#define VS global variables - enum

define informs the preprocessor to do a textual substitution (a macro)
global variables - enum - declares a (constant) variable.

so its like macro VS const variable.

The global variables - enum

they obey the language's scoping rules
you can see them in the debugger
you can take their address if you need to
you can pass them by const-reference if you need to
they don't create new "keywords" in your program.

you should use global variables and enum for constants, not #define.

How we import global variables?

1) Add 2 new files to your project: "GlobalValues.h" and "GlobalValues.m".
2) Open "GlobalValues.h", and declare all your needed variables.

//name of the 'service' used for storing items in the user's keychain:
extern NSString const *MYKeychainServiceName;

//name of the PasteBoard data type that application uses for document data:
extern NSString const *MYPboardDataType;

3) Open "GlobalValues.m", and start the new file by importing "GlobalValues.h".
4) Then, assign values to the variables you declared in the header file:

#import "GlobalValues.h"

//name of the 'service' the application uses for storing items in the user's keychain:
NSString const *MYKeychainServiceName = @"MyApplication Password";
//name of the PasteBoard data type that application uses for document data:
NSString const *MYPboardDataType = @"MyApplication DocData";

In the implementation files of the classes that need to use these variables, you would put - at the very beginning:

#import "GlobalValues.h"

#source:
Big Nerd Ranch Guide - Objective C programming
http://www.cocoadev.com/index.pl?GlobalVariablesInCocoa

NSArray remove ObjectIdenticalTo VS removeObject:

2012-09-28T02:03:00.000-07:00

NSArray remove ObjectIdenticalTo VS removeObject:

copy (and not paste!) from book BigNerd Ranch iOS programming (2012) page 214

removeObject: goes to each object in the array and sends it the message isEqual:. A class can implement this method to return YES or NO based on its own determination.
removeObjectIdenticalTo: removes an object if and only if it is exact same object as the one passed in this message.

How to pass arguments in object C - xcode programes

2012-09-28T02:00:00.000-07:00

How to pass arguments in object C - xcode programes

in Xcode:

Choose Produce from menu
Choose Edit Scheme
Select Run ApplicationName on the left
Select Arguments tab
Add Arguments with + on Arguments Passed on Launch

JSON format

2012-09-28T01:59:00.000-07:00

JSON format

JSON (JavaScript Object Notation) is a lightweight data-interchange format. It is easy for humans to read and write. It is easy for machines to parse and generate. It is based on a subset of the JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999. JSON is a text format that is completely language independent but uses conventions that are familiar to programmers of the C-family of languages, including C, C++, C#, Java, JavaScript, Perl, Python, and many others. These properties make JSON an ideal data-interchange language.
JSON is built on two structures:

A collection of name/value pairs. In various languages, this is realized as an object, record, struct, dictionary, hash table, keyed list, or associative array.
An ordered list of values. In most languages, this is realized as an array, vector, list, or sequence.

These are universal data structures. Virtually all modern programming languages support them in one form or another. It makes sense that a data format that is interchangeable with programming languages also be based on these structures.
In JSON, they take on these forms:
An object is an unordered set of name/value pairs. An object begins with { (left brace) and ends with } (right brace). Each name is followed by : (colon) and the name/value pairs are separated by , (comma).

An array is an ordered collection of values. An array begins with [ (left bracket) and ends with ] (right bracket). Values are separated by , (comma).

A value can be a string in double quotes, or a number, or true or false or null, or an object or an array. These structures can be nested.

A string is a sequence of zero or more Unicode characters, wrapped in double quotes, using backslash escapes. A character is represented as a single character string. A string is very much like a C or Java string.

A number is very much like a C or Java number, except that the octal and hexadecimal formats are not used.

Whitespace can be inserted between any pair of tokens. Excepting a few encoding details, that completely describes the language.

Bitwise operator OR and AND - in objective C - Exclusive OR - Complements - Shifting and Enum

2012-09-28T01:57:00.002-07:00

Bitwise operator OR and AND - in objective C - Exclusive OR - Complements - Shifting and Enum

| is the bitwise-OR operator in C.

You will see the bitwise-OR operator a lot in Cocoa and iOS programming.
You can use bitwise-OR together the constants that represent the particular aspects you want.

NSError *e;
NSDataDetector *d = [NSDataDetector dataDetectorWithTypes:
NSTextCheckingTypePhoneNumber | NSTextCheckingTypeDate
error:&e];

In objective-C we use bitwise-AND (&) to see if a certain bit, or flag is on.

if ([currentDetector checkingTypes] & NSTextCheckingTypePhoneNumber){
NSLog (@"This one is looking for phone numbers");
}

^ exclusive OR (XOR) - two bytes together to create a third (beware is not exponentiation operator=pow())
complement is the byt that is the exact opposite of another (reverse all the 0 to 1 and all the 1 becomes 0).
A<<2 .="." b="b" nbsp="nbsp"><< Left-shift

. Every time you left -shift a number one place, you double tis value.

A>>1. >>Right-shift. Every time you right-shift a number one place, you half its value (if it is odd round down).

An elegant way to declare the bit-masks with enum
enum {
UIDataDetectorTypePhoneNumber = 1 << 0,
UIDataDetectorTypeLink = 1 << 1,
UIDataDetectorTyprAddress = 1 << 2,
UIDataDetectorTypeNone =0,
UIDataDetectorTypeAll = NSUIntegerMax
};

examples from The big Nerd Ranch Guide - Objective C

What Is Key-Value Coding?

Key-value coding is a mechanism for accessing an object’s properties indirectly, using strings to identify properties, rather than through invocation of an accessor method or accessing them directly through instance variables. In essence, key-value coding defines the patterns and method signatures that your application’s accessor methods implement.

Accessor methods, as the name suggests, provide access to your application’s data model’s property values. There are two basic forms of accessor—get accessors and set accessors. Get accessors, also referred to as getters, return the values of a property. Set accessors, also referred to as setters, set the value of a property. There are getter and setter variants for dealing with both object attributes and to-many relationships.

Implementing key-value coding compliant accessors in your application is an important design principle. Accessors help to enforce proper data encapsulation, isolatememory management to centralized locations, and facilitate integration with other technologies such as key-value observing, Core Data, Cocoa bindings, and scriptability. Key-value coding methods can, in many cases, also be utilized to simplify your application’s code. See Model Object Implementation Guide for more guidance on why your application should implement key-value coding compliant accessors and make use of them.

The essential methods for key-value coding are declared in the NSKeyValueCoding Objective-C informal protocol and default implementations are provided by NSObject.

Key-value coding supports properties with object values, as well as the scalar types and structs. Non-object parameters and return types are detected and automatically wrapped, and unwrapped, as described in “Scalar and Structure Support.”

examples:

Object types:

[a setProductName:@"Washing Machine"]

[a setValue:@"Washing Machine" forKey:@"productName"];

[a valueForKey:@"productName"]

Non-object types

[a setVoltage:240];

[a setValue:[NSNumber numberWithInt:240] forKey:@"voltage"];

some notes from The Big Nerd Ranch Guide:

Note that even though you have no accessor methods for one object, the variable can still be set and read from others methods (via key-value coding). This is an obvious violation of the idea of object encapsulation - methods of an object are public, but the instance variables are delicate and should be kept private. If key-value coding weren't astonishingly useful, no one would tolerate it.

and from stackoverflow

Charbonneau is correct. I get an XML feed in which corresponds to an object on the iPhone/Mac client. Typically it'll be something like Bob43 I had a method before that would key/value code NSDictionary instances. – Coocoo4Cocoa Dec 18 '08 at 20:53

Blocks

2012-09-28T01:53:00.002-07:00

Blocks

^(double div, double divisor) {
double quotient = div / divisor;
return quotient;
};

^: identifies a block

Block can take arguments

If you want to access a block by a name, we have to assign it to a block variable.

void (^devow) (id, NSUInteger, BOOL *)
Block variable declaration

notice that the block assignment ends with a semi-colon just like any variable assignment would.

You can use typedef to declare a block at the start of top of the file like
typedef void (^ArrayEnumerationBlock) (id, NSUInteger, BOOL *);

Rather to write: void (^devowelizer) (id, NSUINteger, BOOL *);
you can write: ArrayEnumerationBlock devowelizer;

If a block returns a value you can call that block variable like a function

double (^divinationBlock) (double, double) = ^(double k, double j) {
return k/j;
}

Blocks are created and stored on the stack and will be destroyed (with the stack) when the function or method that created the block returns. To copy a block from the stack to the heap, you send it the copy message:
ArrayEnumerationBlock iVarSomething = [something copy]; (now the new block variable is a pointer to the block).Methods that takes blocks as arguments, are expected to copy blocks passed to them.
A heap-based block behaving like an object comes with some memory management issues:

#Source: The Big Nerd Ranch Guide (Objective C) - kindle version

external variables are captured by the block when the copy is made.
to avoid retain cycles declare a __weak pointer outside the block
variables captured by a block are constant within the block and you cannot change their values (you can still send the object messages that can change its contents, you cannot modify the pointer itself).
if you want to change them you need to use __block otherwise you get compilation error.

__block int counter =0 ;

void (^counterBlock) () = ^ {counter++;};

...

counterBlock (); //Increments counter to 1

counterBlock ();//Increments counter to 2

Wy shouldn't I use accessor methodes in an init method?

2012-09-28T01:52:00.000-07:00

Wy shouldn't I use accessor methodes in an init method?

First: Apples Documentation says so...

Don’t Use Accessor Methods in Initializer Methods and dealloc

The only places you shouldn’t use accessor methods to set an instance variable are in initializer methods and dealloc. To initialize a counter object with a number object representing zero, you might implement an init method as follows:

- init {

self = [super init];

if (self) {

_count = [[NSNumber alloc] initWithInteger:0];

}

return self;

}

To allow a counter to be initialized with a count other than zero, you might implement an initWithCount: method as follows:

- initWithCount:(NSNumber *)startingCount {

self = [super init];

if (self) {

_count = [startingCount copy];

}

return self;

}

Since the Counter class has an object instance variable, you must also implement a dealloc method. It should relinquish ownership of any instance variables by sending them a release message, and ultimately it should invoke super’s implementation:

- (void)dealloc {

[_count release];

[super dealloc];

}

What stackoverflow says?

It's basically a guideline to minimize the potential for bugs.
It is all about using idiomatically consistent code. If you pattern all of your code appropriately there are sets of rules that guarantee that using an accessor in init/dealloc is safe.

What Big Nerd Ranch guide says?
"..In most cases, there is a little reason to do one over the other, but it makes for a great argument. The argument goes like this: The assign guy says, "You can't use an accessor method in an init method! The accessor asumes that the object is ready for work, and it isn't ready for work until after the init method is complete." Then the accessor method guy says, "Oh, come on. In the real world that is almost never an issue. My accessor method might be taking care of other stuff for me. I use my accessor anytime I set that variable." In reality, either approach will work in the cast majority of cases.

Top-level HeaderDoc tags

2012-09-28T01:50:00.003-07:00

Top-level HeaderDoc tags

Tag	Example	Identifies
@availabilitymacro	@availabilitymacro AVAILABLE_IN_MYAPP_1_0_AND_LATER Available in MyApp v1.0 and later.	This tag tells HeaderDoc that whenever the named token appears in a declaration, the token should be deleted and the “Availability:“ attribute for that declaration should be set to the string that follows.
@class	@class myClass	The name of the class.
@category	@category myCat(owningClass)	The full name of the category, as declared in the header. For example, “MyClass(MyCategory)”. HeaderDoc uses the “MyClass” portion of the name to identify the associated class.
@protocol	@protocol myProtocol	The name of the protocol.
@const or @constant	@constant MyConst	Specifies the name of the constant.
@define @defined	@define MyDefine	Name of the macro.
@function	@function myFunc	The name of the function. Note: For historical reasons, you can also mark up function-like macros with the @function tag. However, this is not recommended.
@enum	@enum MyEnum	The name of the enumeration. This is usually enum's tag, if it has one. Otherwise, supply a name you want to have the constants grouped under in the documentation. The member fields should be enumerated with the@constant tag.
@file	@file Filename Discussion goes here.	See @header.
@framework	@framework Kernel Framework	The name of the framework. Must be in a file ending in .hdoc. This name is inserted as part of the master TOC (landing page) generation process wherever the$$framework@@ tag appears.
@functiongroup	@functiongroup My Function Group	The name of the function group.
@header	@header Repast Manager	The name under which the API is categorized. Leave the name blank to just use the header filename. The following additional subtags are available: @CFBundleIdentifier @charset @compilerflag @encoding @flag @ignore @ignorefuncmacro @preprocinfo @related
@method	@method myMethod:	The name of the Objective-C method. Note: For historical reasons, you can also mark up C++ methods with the @method tag. However, this is not recommended.
@property	@property myPropName	The name of the Objective-C property.
@struct	@struct myStruct	The name of the structure. (Also known as the structure’s tag.)
@typedef	@typedef MyType	The name of the defined type.
@union	@union myUnion	The name of the union. (Also known as the union's tag.)
@var	@var myVariable	The name of a global variable or class member variable.

Identical vs isEqual

2012-09-28T01:47:00.002-07:00

Identical vs isEqual

-(BOOL) isEqual: (id) other	-(NSUInteger)indexOfObjectIdenticalTo:(id)anObject;
if isEqual is overrided from the original NSObject simple implementation, usally isEqual means they have the same componets one by one example two strings are isEqual if they have the same letters in the same order.	Same pointers “== an Object” Example two strings are Identical if they contain the exact same address.

Why to use pointers?

2012-09-28T01:46:00.000-07:00

char *startOfASeriesOfChars ;

Imagine a very long string like the above.
Is not always possible to pass a copy of your data (above)
but you can always pass the address of where that data begins.

Same reason is, why the object in objective C are pointers.
How easy is to pass a big object as argument?
Obviously is easy if it's a pointer.

Pointers are also called references.
Thus, using the pointer to read data at the address is sometimes called dereferencing pointer.

Warning:
float *c, *d; // is the correct
float* c, b; // c is pointer to a float, b is float!!

iPhone Development Flow chart.

2012-09-28T01:27:00.002-07:00

iPhone Development Flow chart.

Recording a voice audio in iPhone

2012-09-28T01:26:00.002-07:00

Recording a voice audio in iPhone

This tutorial explains how to record a voice in iPhone.

There are multiple ways to record audio on the iPhone, but some are suited to tasks better than others. I'm going to show you a simple way to record audio into a file and get its power level (volume if you will). This tutorial makes use of the AudioToolbox framework which you must add to your project to get this code working. Firstly I highly recommend you make your own AudioRecorder class to deal with the low level recording, that way you can just port your class from project to project with little hassle, and save time writing your own code. Firstly create a header file like so:

#import
#import
#import

@interface AudioRecorder : NSObject
{
AudioStreamBasicDescription dataFormat;
}

-(id) init;

@end

This adds a description of your audio stream to your class, now you will want to write your initialisation code in your main file, this is where we will fill the dataFormat instance variable.

-(id) init
{
dataFormat.mSampleRate = 44100.0f;
dataFormat.mFormatID = kAudioFormatLinearPCM;
dataFormat.mFramesPerPacket = 1;
dataFormat.mChannelsPerFrame = 1;
dataFormat.mBytesPerFrame = 2;
dataFormat.mBytesPerPacket = 2;
dataFormat.mBitsPerChannel = 16;
dataFormat.mReserved = 0;
dataFormat.mFormatFlags = kLinearPCMFormatFlagIsBigEndian | kLinearPCMFormatFlagIsSignedInteger | kLinearPCMFormatFlagIsPacked;
return self;
}

Basically what this code is saying is that we want a mono recording (mChannelsPerFrame) at a sample rate of 44.1kHz (mSampleRate) using SInt16's (mBytesPerFrame and kLinearPCMFormatFlagIsSignedInteger) and that we are recording in Linear PCM (pretty standard). So now that we have sorted those parameters out, we need to add the Audio Queue and the Input Callback, this means not only another instance variable in our header, but also a function that is outside the scope of the class, however by cleverly inputting the right data we can make it work for multiple instances of the class.

@interface AudioRecorder : NSObject
{
AudioStreamBasicDescription dataFormat;
AudioQueueRef queue;
}

@property AudioQueueRef queue;

// Our new C callback
void AudioInputCallback(void* inUserData,AudioQueueRef inAQ,AudioQueueBufferRef inBuffer,const AudioTimeStamp *inStartTime,UInt32 inNumberPacketDescriptions,const AudioStreamPacketDescription *inPacketDescs)
{
}
// Declaring the get/set of our new public variable
@synthesize queue;
// Add this code to the init function
if(AudioQueueNewInput(&dataFormat,AudioInputCallback,self,CFRunLoopGetCurrent(),kCFRunLoopCommonModes,0,&queue) == noErr)
{
}

So this declares the queue variable public, adds our AudioInputCallback C function, and inputs data into our audio queue. Next we have to deal with our audio buffers:

// Add this variable to our interface
AudioQueueBufferRef buffers[3];

// Add this code into our init function
for(int i=0;i<3 br="br" i="i">{
AudioQueueAllocateBuffer(queue,(dataFormat.mSampleRate/10.0f)*dataFormat.mBytesPerFrame,&buffers[i]);
AudioQueueEnqueueBuffer(queue,buffers[i],0,nil);
}

This allocates our buffers with the right amount of space, and then Enqueue's them to await our audio recording input. Next we will kick start the process by using the AudioQueueStart function.

AudioQueueStart(queue, NULL);

Now we have a functioning audio recording code, you will notice if you put logs into AudioInputCallback, you will see it gets called every so often (ie when the buffers will up), however in the callback we will need to handle the continued Enqueue of our buffers defined in the interface, so we will need to add this into the AudioInputCallback function:

AudioRecorder* recorder = (AudioRecorder*) inUserData;
AudioQueueEnqueueBuffer(recorder.queue,inBuffer,0,nil);

Now what this does is grabs our AudioRecorder class from the inUserData, then uses the queue defined in that class to enqueue the next buffer for getting more audio. Now we are functioning, but what about writing the recorded audio data to a file or getting the power of an audio recording? Well that's coming here, first I'll focus on the power level (because it's much easier than writing file data):

// Define these functions in the interface
-(float) getPeakPower;
-(float) getAveragePower;

// At the end of init
UInt32 enabledLevelMeter = true;
AudioQueueSetProperty(queue,kAudioQueueProperty_EnableLevelMetering,&enabledLevelMeter,sizeof(UInt32));
// New functions
-(float) getPeakPower
{
AudioQueueLevelMeterState levelMeter;
UInt32 levelMeterSize = sizeof(AudioQueueLevelMeterState);
AudioQueueGetProperty(queue,kAudioQueueProperty_CurrentLevelMeterDB,&levelMeter,&levelMeterSize);
return levelMeter.mPeakPower;
}

-(float) getAveragePower
{
AudioQueueLevelMeterState levelMeter;
UInt32 levelMeterSize = sizeof(AudioQueueLevelMeterState);
AudioQueueGetProperty(queue,kAudioQueueProperty_CurrentLevelMeterDB,&levelMeter,&levelMeterSize);
return levelMeter.mAveragePower;
}

Now you can simply call getPeakPower or getAveragePower to obtain the average or peak power of the audio being recorded in decibels. Now I usually gauge power by dividing the Average Power by -80.0, because I use that as a ceiling, and yes I am well aware volume can get up to 120dB in power, but for most purposes a ceiling of 80dB is fine. Now for the complex stuff, file writing. What we are going to do is add a specific function to our class that allows us to define a file to write to, and some functions that tell us whether we are recording to a file or not as well as allowing us to stop the file recording.

// New interface variables
AudioFileID audioFile;
bool fileRecording;
SInt64 currentPacket;
NSString* recordFile;
// Functions to add to our class
-(bool) isRecording;
-(bool) record:(NSString*)filename;
-(void) stopRecording;

-(bool) isRecording
{
return fileRecording;
}

-(bool) record:(NSString*)file
{
char cfile[256];
[file getCString:cfile maxLength:sizeof(cfile) encoding:NSUTF8StringEncoding];
CFURLRef fileURL = CFURLCreateFromFileSystemRepresentation(NULL,(UInt8*)cfile,strlen(cfile),false);
OSStatus result = AudioFileCreateWithURL(fileURL,kAudioFileAIFFType,&dataFormat,kAudioFileFlags_EraseFile,&audioFile);
if(result != noErr)
fileRecording = false;
else fileRecording = true;
if(fileRecording)
recordFile = file;
return fileRecording;
}

-(void) stopRecording
{
fileRecording = false;
AudioFileClose(audioFile);
}

Now there's a lot of code here, so I'll try to explain it. The isRecording function basically informs other classes on whether we are currently recording, the record function is where our imagine happens. It uses AudioFileCreateWithURL to create an audio file header based on our format definition in the earlier part of this tutorial, the rest of that function is basically setting the recording fileRecording variable and changing the NSString to a CFURLRef type. The stop recording function is also very self explanatory, it just closes the audio file and shutdowns the fileRecording variable. But we still aren't using the AudioInputCallback to record! Well that's the last piece of the puzzle:

// Add these properties to the interface
@property AudioFileID audioFile;
@property bool fileRecording;
@property SInt64 currentPacket;

// Add this code to AudioInputCallback
if(recorder.fileRecording)
{
AudioFileWritePackets(recorder.audioFile,false,inBuffer->mAudioDataByteSize,inPacketDescs,recorder.currentPacket,&inNumberPacketDescriptions,inBuffer->mAudioData);
recorder.currentPacket += inNumberPacketDescriptions;
}
// Synthesize these variables
@synthesize audioFile,fileRecording,currentPacket;

Now here we basically make the fileRecording, audioFile and currentPacket variable public, so we can use them in the AudioInputCallback, then we write the audio packets to our file. It's as simple as that.

Different kinds of file Parsing in iPhone

2012-09-28T01:24:00.001-07:00

Different kinds of file Parsing in iPhone

1)HTML File Parsing

Example-1

Example-2

2)XML File Parsing

Example-1

Example-2

Knowledge of XPath

Following Tutorial Describes two common XML parsing mode (NSXMLParser & GDataXMLNode)

Commonly used analytical XML are two ways, they are based on a different API :
1.Tree-based API : The API approach is to XML as a tree structure, then the various parts of the tree as an object to handle, this is what we mean DOM (Document Object Model) approach. In the iPhone 's SDK contains a libxml2 framework (Framework) will be able to DOM parsing mode.Google 's GDataXML is also based on libxml2 , and therefore the use of GDataXML , you need to first import libxml2 .

2.Event-driven API: This is often used to resolve event-based, SAX parsing mode is representative of this analytical method. In the iPhone developed in this way can also be used to parse XML , but this is not Iphone SDK attributes ah, but Objective-C functions. In Objectvie-C species have special parsing XML class NSXMLParser .

NSXMLParser and CGataXML to use:

1. NSXMLParser analytical method
NSXMLParser parsing XML in the main work is relied on the agent (NSXMLParserDelegate) to achieve.

- ( void ) {viewDidLoad
[ Super viewDidLoad ];
//........
NSXMLParser * Parser = [[ NSXMLParser alloc ] initWithContentsOfURL : [ NSURL URLWithString : @ " http://lab.xxxxxx.com/xxx/xxx.xml " ]];
[Parser setDelegate : self ];
[Parser parse ];

for ( int i = 0 ; i <[ newsArray count ]; i + +) {
NSLog ( "%@" , [ newsArray objectAtIndex : i]);
}
}
To so few, they begin to resolve, and how to get XML data inside it?
Then go to agents to find it inside!
# Pragma mark NSMXLParser Delegate Methods
- ( void ) Parser: ( NSXMLParser *) Parser didStartElement: ( NSString *) elementName
namespaceURI: ( NSString *) namespaceURI QualifiedName: ( NSString *) qName attributes: ( NSDictionary *) attributeDict {
if ([elementName isEqualToString : @ "DocTitle" ]) {
if (! newsArray ) {
newsArray = [[ NSMutableArray alloc ] init ];
return ;
}
}
}

- ( void ) Parser: ( NSXMLParser *) Parser foundCharacters: ( NSString *) {String
if (! currentString ) {
currentString = [[ NSMutableString alloc ] init ];
}
[ currentString appendString : String];
[ currentString setString : [ currentString stringByTrimmingCharactersInSet : [ NSCharacterSet whitespaceAndNewlineCharacterSet ]]];
}

- ( void ) Parser: ( NSXMLParser *) Parser didEndElement: ( NSString *) elementName
namespaceURI: ( NSString *) namespaceURI QualifiedName: ( NSString *) qName {
if ([elementName isEqualToString : @ "DocTitle" ]) {
[ newsArray addObject : currentString ];
}
[ currentString Release ];
currentString = nil ;
}
Let me talk about the process to run, when the parser to initialize and run parse statement ([Parser parse ]), the program will jump to the first proxy agent approach which way to go. Method will be the first agent xml traverse again, and identify xml element name inside (elementName) , I'm looking at the information found (docTitle) , create an array to store the information, and of course not the first agent begin storing information.
The next will take a second agent, it will the first phase we are looking for agent information is stored in currentString in. Which I added a deal on access to the string statement [ currentString setString : [ currentString stringByTrimmingCharactersInSet : [ NSCharacterSet whitespaceAndNewlineCharacterSet ]]] , it can start the string with spaces and line breaks removed (as often encountered xml file format not standard).
Finally, the third proxy methods to access the information stored in our array.
Of course, this three-step program is running in the order of execution is not so strict, and the execution will be repeated, but generally the process is this.

1. DOM parsing method of GDataXMLNode
GDataXMLNode is based on libxml2 the third-party documents, more powerful features.
NSError * Error = nil ;
NSString * documentStr = [[ NSString alloc ] initWithContentsOfURL : [ NSURL URLWithString : @ "http://www.xxxx.com/x/xxx.xml" ] encoding : NSUTF8StringEncoding Error : & Error];
GDataXMLDocument * XMLDocument = [[ GDataXMLDocument alloc ] initWithXMLString : documentStr Options : 0 Error : & Error];
[DocumentStr Release ];
GDataXMLElement * rootElement = [XMLDocument rootElement ];
NSArray * newsArray = [rootElement elementsForName : @ "DocTitle" ];
for ( int i = 0 ; i <[newsArray count ]; i + +) {
NSLog ( "%@" , [[newsArray objectAtIndex : i] stringValue ]);
}
To so few, features, and above NSXMLParser , of course, is stored in the array GDataXMLElement objects rather than strings.
In the DOM parsing mode, the first XML file into an object or link, here is GDataXMLDocument object, and then each part of the object which is seen as an object, such as rootElement a GDataXMLElement object, which is the XML root of the tree , including the XML of all information. We directly rootElement look under the name: DocTitle the object, put it inside the array (because such objects may be more than one). We want to take docTitle object inside the contents of theHello iPhone , the object stringValue is.

@property(nonatomic, retain) ?

2012-09-28T01:23:00.002-07:00

@property(nonatomic, retain) ?

By default, property accessors are atomic. Also there is no "atomic" keyword, if you do not specify "nonatomic" then the property is atomic, but specifying "atomic" explicitly will result in an error.

So if any one write

@property(atomic, retain) UITextField *userName;
or
@property(retain) UITextField *userName;

They mean the same thing.

So an Atomic accessors in a non garbage collected environment (i.e. when using retain/release/autorelease) will use a lock to ensure that another thread doesn't interfere with the correct setting/getting of the value.

With atomic, the synthesized setter/getter will ensure that a whole value is always returned from the getter or set by the setter, regardless of setter activity on any other thread. That is, if thread A is in the middle of the getter while thread B calls the setter, an actual viable value -- an autoreleased object, most likely -- will be returned to the caller in A.

In nonatomic, no such guarantees are made. Thus, nonatomic is considerably faster than atomic.

What atomic does not do is make any guarantees about thread safety. If thread A is calling the getter simultaneously with thread B and C calling the setter with different values, thread A may get any one of the three values returned -- the one prior to any setters being called or either of the values passed into the setters in B and C. Likewise, the object may end up with the value from B or C, no way to tell.

@Property attributes
Writability	readwrite	mutually exclusive	*default*	Indicates that the property should be treated as read/write
	readonly			only a getter method is required if you attempt to assign a value using the dot syntax, you get a compiler error. A readonly property can redelcare it as readwrite in a class extension, a protocol or in a subclass.
Setter Semantics	assign (iOS 5) unsafe_unretain (iOS4)		*default*	setter uses simple assignment (new value not retained, old value is not released). use this for scalar types (NSInteger, CGRect in Ref.Counted env. on dealloc method make sure that object propertis marked assign are not released and the not assign are released. property=newValue;
	retain strong	if (property!=newValue){ [property release]; property = [newValue retain];		retain should be invoked on the object upon assignment the previous value is sent a release message valid only for Objective-C object types (no for Core Foundation)
		_attribute_		use attribute keyword to specify that a Core foundation property should be treated like an Objective C for memory management
	copy	if (property!=newValue){ [property release]; property = [newValue copy]; }		a copy of the object should be used for assignment previus value is sent a release message valid only for objects that implement the NSCopying protocol *WARNING*-the copy method returns an immutable version of a collection, so if you want a mutable version you need to implement the setter rather to synthesize it.
Atomicity	nonatomic			Specify that accessor methods are not atomic (by default accessors are atomic=robust access to properties in a multithreaded environment) If you specity retain or copy with not the noatomic, then in a reference-counted environment, a synthesized get accessor for an object property uses a lock and retains and autoreleases the returned value (similar to code below nonatomic)
	[_internal lock]; //lock id result = [[value retain] autorelease]; [_internal unlock]; return result;
Interface Outlet	IBOutlet			To specify that a property is an Interface Builder oulet @property (nonatomic, retain) IBOutlet NSButton *myButton;

IOS codes

iOS 5 : Customize UINavigationBar and UIBarButtonItem with the Appearance API

Change UINavigationBar Background

shouldAutorotateToInterfaceOrientation not getting called in iOS 6

How to get the attributes of an instance of NSTableView

How to get the attributes of an instance of NSTableView

How can you suppress compilers warning "can't find an implementation of accessor methods"

How can you suppress compilers warning "can't find an implementation of accessor methods"

A summary of property-properties attributes - and some tips

A summary of property-properties attributes - and some tips

Retain Cycle

Retain Cycle

Callbacks - short notes

isa - super - self

isa - super - self

How we import (constant) global variables and #define VS global variables

How we import (constant) global variables and #define VS global variables

NSArray remove ObjectIdenticalTo VS removeObject:

NSArray remove ObjectIdenticalTo VS removeObject:

How to pass arguments in object C - xcode programes

How to pass arguments in object C - xcode programes

JSON format

JSON format

Bitwise operator OR and AND - in objective C - Exclusive OR - Complements - Shifting and Enum

Bitwise operator OR and AND - in objective C - Exclusive OR - Complements - Shifting and Enum

Categories

Categories

NSLog - Tokens - %@ - %p memory token, %zu size_T token (tip to find the type (32 or 64 bit) of environment)

NSLog - Tokens - %@ - %p memory token, %zu size_T token (tip to find the type (32 or 64 bit) of environment)

What Is Key-Value Coding?

Blocks

Blocks

Wy shouldn't I use accessor methodes in an init method?

Wy shouldn't I use accessor methodes in an init method?

Top-level HeaderDoc tags

Identical vs isEqual

Identical vs isEqual

Identical vs isEqual

Why to use pointers?

iPhone Development Flow chart.

iPhone Development Flow chart.

Recording a voice audio in iPhone

Recording a voice audio in iPhone

Different kinds of file Parsing in iPhone

Different kinds of file Parsing in iPhone

@property(nonatomic, retain) ?

@property(nonatomic, retain) ?