Category Archives: iOS

Block basics

September 9, 2015C/C++/Objective-C, iOSadmin

reference
http://stackoverflow.com/questions/22996536/resolving-retain-cycles-is-there-really-a-reason-to-add-strong-strongself-wh?rq=1
http://rypress.com/tutorials/objective-c/blocks

http://www.cocoawithlove.com/2009/10/how-blocks-are-implemented-and.html

demo xCode 7.3

How To Declare

Interface: We have the return type. Then block name. Then the parameters.

Then a equals sign, which leads to our declaration of the block. In the declaration of the block, be sure to name your parameters.

return type (^blockName) ( param type, param type,... ) = ^( type param1, type param2 ) {

// code

};

int (^firstBlock)(NSString *param1, int param2) = ^(NSString * name, int age) {

return 0;

};

non-local variables are variables defined in the block’s enclosing lexical scope, but outside the block itself.

non-local variable are copied and stored with the block as const variable, which means they are read-only.

In other words, it creates “const” copy of any local variables that is referenced inside its scope.

Global Blocks – not referencing any non-local variables

With no references to the surrounding scope, clang configures the Block_literal as a global block instead.

For example,

NSString * (^firstBlock)(NSString *param1, int param2) = ^(NSString * name, int age) {

return [NSString stringWithFormat:@"%@ is %d years old", name, age];

};

If you’re familiar with how Objective-C objects are declared, the isa field in the Block_literal above should be familiar — blocks are Objective-C objects.

As you see, it does not reference any non-local variables. Thus, the compiler creates it as a global block:

This causes the block to appear in a fixed global location instead of on the local stack.

The implication of this is that global blocks are never actually copied or disposed, even if you invoke the functions to do so. This optimization is possible because without any references to the surrounding scope, no part of the block (neither its code nor its Block_literal) will ever change — it becomes a shared constant value.

Malloc Blocks – __strong block definitions

void (^whisper)() = ^() {

NSLog(@"someone has %d dollars", dough);

};

The block object was retained by the whisper variable. The strong sends a retain to the block. When a block is retained, it invokes a copy on it.

block implementation detail:

id objc_retainBlock(id x) {

return (id)_Block_copy(x);

}

Thus, the block object was moved from stack to heap by this _Block_copy. But note that there is only still 1 copy of the block. It simply increases the retain count of the block.

Stack Blocks – __weak block definitions

http://stackoverflow.com/questions/25794306/could-you-help-me-to-understand-block-types-when-added-to-containers-nsdictiona

http://stackoverflow.com/questions/19227982/using-block-and-weak

Marking it as __weak causes the whisper variable to NOT retain the block object.
Thus, the block starts off being allocated on the local stack, and it stays there. Since there is no __strong to retain it, and thus, no copy.

therefore, a weak block variable on a block object keeps the block object on the local stack.

//This knowingly leads to dangling pointers if the Block (or a copy) outlives the lifetime of this object.

__weak void (^whisper3)() = ^() {

NSLog(@"another block %d", localVariable);

};

If you copy an NSStackBlock, it will return an NSMallocBlock (indicating its changed allocation location).

A block keeps it’s own array of its non-local variables via deep copy

example:

int main(int argc, const char * argv[])

{

NSString *make = @"Honda"; //non-local variable

NSString *(^getFullCarName)(NSString *) = ^(NSString *model) {

//make = nil; //Trying to assign new value to the make variable

// from inside the block will throw a compiler error.

//Non-local variables are COPIED (deep copy) and stored with

//the block as const variables (cannot be changed), which means they are read-only.

//The fact that non-local variables are copied as constants means that a

//block doesn’t just have access

//to non-local variables—it creates a snapshot of them.

return [make stringByAppendingFormat:@" %@", model];

};

NSLog(@"%@", getFullCarName(@"Accord")); // Honda Accord

make = @"BMW";

NSLog(@"%@", make); //BMW

NSLog(@"%@", getFullCarName(@"Civic")); // Honda Civic

}

So as you can see, the non-local variable make gets copied inside of the block getFullCarName. If you try to modify make inside of the block getFullCarName, you will see a compiler error.

Notice how later, outside of the block, we change the variable make to “BMW”. However, its a deep copy, this change takes place at the outside of the closure. Hence the original make variable (outside of the closure) is BMW. The copy inside the block, the make is still Honda. We see this happening by passing @”Civic” into getFullCarName(…).

You can make non-local changeable by using __block to use them as reference

Freezing non-local variables as constant values is a safe default behavior
in that it prevents you from accidentally changing them from within the block;
however, there are occasions when this is NOT desirable.

You can override the const copy behavior by declaring a non-local variable with the __block storage modifier:

1	__block NSString *make = @"Honda";

This tells the block to capture the variable by reference, whereas if you didn’t have __block, it would capture it by deep copy.

When the block captures the variable by reference, its like creating a direct link between the variable outside the block and the one inside the block.
You can now assign a new value to make from outside the block, and it will be reflected in the block, and vice versa.

__block int i = 0;

int (^count)(void) = ^ {

i += 1;

return i;

};

NSLog(@"%d", count()); // 1

NSLog(@"%d", ++i); //2

NSLog(@"%d", count()); // 3

NSLog(@"%d", ++i); //4

NSLog(@"%d", count()); // 5

So now, you are referencing the same variable outside and inside the block. Whereas before, you have 2 deep copies of the variable depending on whether you are outside or inside of the closure.

Each block has its own copy of the non-local variables

In the example below, if we call existingBlock or vv twice, you will see that the non-blocking variables that they copy will have the same address. Their local variables, however, are all different throughout the calls. That’s because for the local variables of the block, they just go on the stack. Where as the outside scope’s variable are all copied….in an array for that particular block.

void foo(int param)

{

int x0 = param; //stack local variable, blocks will have their own copy of this variable

int x1 = param + 1; //stack local variable, blocks will have their own copy of this variable

void (^existingBlock)(void) = ^{

NSLog(@"----------existingBlock START ------");

int y0 = 8;

int y1 = 88;

printf("existingBlock: local variable y0 address is %p\n", &y0); //existingBlock local variable

printf("existingBlock: local variable y1 address %p\n", &y1); //existingBlock local variable

printf("existingBlock non-local x0 address %p\n", &x0); //existingBlock non-local variable copy

printf("existingBlock non-local x1 address %p\n", &x1); //existingBlock non-local variable copy

NSLog(@"----------existingBlock END ------");

};

void (^vv)(void) = ^{

NSLog(@"----------vv START ------");

int y2 = 888;

int y3 = 8888;

existingBlock();

printf("vv: local variable y2 address is %p\n", &y2); //vv's local variable

printf("vv: local variable y3 address is %p\n", &y3); //vv's some local variable

printf("vv: non-local variable x0 address is %p\n", &x0); //vv's non-local variable copy

printf("vv: non-local variable x1 address is %p\n", &x1); //vv's non-local variable copy

NSLog(@"----------vv END ------");

};

NSLog(@"Stack: &x: %p, %u \n", &x0, x0);

NSLog(@"Stack: &x: %p, %u \n", &x1, x1);

NSLog(@"------- on main thread -------\n");

vv();

dispatch_async(dispatch_get_global_queue(0, 0), ^{

NSLog(@"THREAD 2 start");

assert(vv);

sleep(1);

int y4 = 6680;

int y5 = 6868;

vv();

printf("dispatch async local variable y4 address: %p\n", &y4);

printf("dispatch async local variable y5 address: %p\n", &y5);

printf("non-local variable x0 address: %p\n", &x0); //block's non-local variable

printf("non-local variable x1 address: %p\n", &x1); //block's non-local varaible

NSLog(@"THREAD 2 done");

});

}

int main(int argc, const char * argv[])

{

@autoreleasepool {

foo(1);

sleep(2);

}

return 0;

}

But what about Object allocations

As show in the code above, we have a block called vv. vv calls existingBlock block.
Then, say we have an object allocation outside of the block existingBlock at the highest scope at foo function.

We have 2 parts:

1) the reference ptrToStrObj gets pushed onto the local stack,
with address say: 0x7fff5fbff708

2) and the object that’s allocated on the heap, pointed to by reference ptrToStrObj. The object has address say: 0x100102450

LOCAL – address of POINTER ptrToStrObj……0x7fff5fbff708
LOCAL – address of NSString object on heap……0x100102450

The ptrToStrObj variable is a non-local variable, which means it defined in the block’s enclosing lexical scope, but OUTSIDE of the block itself. It is deep copied inside of the block.

We display the address of the the reference ptrToStrObj inside of the block existingBlock, which then shows:

———-existingBlock START ——
existingBlock – address of POINTER ptrToStrObj……0x1020001c0
existingBlock – address of OBJECT……0x100102450
existingBlock – ricky tsao, dob 6680
———-existingBlock END ——

As you can see, the address of the object on the heap remains at 0x100102450.
But the pointer of the reference ptrToStrObj has changed from 0x7fff5fbff708 to 0x1020001c0.

That is proof that the block made a deep copy of the non-local variable reference ptrToStrObj for itself.

Furthermore, if you try to modify ptrToStrObj, it will throw an error:

After calling existingBlock(), we move on to the next line:

changing content of string object
vv – address of POINTER ptrToStrObj……0x102000248
vv – address of OBJECT……0x100102450
vv – HA DO KEN!ao, dob 6680
———-vv END ——

Keep in mind that we are now back in bloc vv.

As you can see, the address of the object in the heap remains the same at 0x100102450.
However, the pointer address changed to 0x102000248. This means that this block vv has its own DEEP COPY of the non-local variable ptrToStrObj.

Thus,

foo’s ptrToStrObj is 0x7fff5fbff708
existingBlock’s ptrToStrObj is 0x1020001c0
vv’s ptrToStrObj is 0x102000248

In much deeper details, each block has an non-local variable array list. That’s where it keeps its list of non-local variables. As we can see in the picture vv block and existingBlock each have an array of non-local variables.

The first item in their array is reference ptrToStrObj. ptrToStrObj points to the object in the heap, which never changes as we can see that the addresses all match.

However the address of the references are different, because each block has their own DEEP COPY of the reference.

Finally, let’s see what happens inside of a GCD block:

dispatch_async(dispatch_get_global_queue(0, 0), ^{

NSLog(@"THREAD 2 start");

assert(vv);

sleep(1);

vv();

NSLog(@"in dispatch_async block - address of POINTER ptrToStrObj......%p", &ptrToStrObj);

NSLog(@"existingBlock - %@", ptrToStrObj);

NSLog(@"existingBlock - address of OBJECT......%p", ptrToStrObj);

NSLog(@"THREAD 2 done");

});

THREAD 2 start
———-vv START ——
———-existingBlock START ——
existingBlock – address of POINTER ptrToStrObj……0x1020001c0
existingBlock – address of OBJECT……0x100102450
existingBlock – HA DO KEN!ao, dob 6680
———-existingBlock END ——
changing content of string object
vv – address of POINTER ptrToStrObj……0x102000248
existingBlock – address of OBJECT……0x100102450
existingBlock – HA DO KEN!N!ao, dob 6680
———-vv END ——
in dispatch_async block – address of POINTER ptrToStrObj……0x100500048
existingBlock – HA DO KEN!N!ao, dob 6680
existingBlock – address of OBJECT……0x100102450
THREAD 2 done

As you can see the object in the heap as address 0x100102450 for all blocks

existingBlock’s ptrToStrObj has 0x1020001c0
vv’s ptrToStrObj has 0x102000248
GCD’s ptrToStrObj has 0x100500048

Hence, as you can see, GCD’s block, like any other blocks, also have its own non-local variable list, and DEEP COPIES the non-local variable reference ptrToStrObj for itself.

Code

void foo(int param)

{

int x0 = param; //stack local variable, blocks will have their own copy of this variable

int x1 = param + 1; //stack local variable, blocks will have their own copy of this variable

NSMutableString * ptrToStrObj = [[NSMutableString alloc] initWithFormat:@"ricky tsao, dob %u", 6680];

NSLog(@"LOCAL - address of POINTER ptrToStrObj......%p", &ptrToStrObj);

NSLog(@"LOCAL - address of NSString object on heap......%p", ptrToStrObj);

void (^existingBlock)(void) = ^{

NSLog(@"----------existingBlock START ------");

NSLog(@"existingBlock - address of POINTER ptrToStrObj......%p", &ptrToStrObj);

NSLog(@"existingBlock - address of OBJECT......%p", ptrToStrObj);

NSLog(@"existingBlock - %@", ptrToStrObj);

NSLog(@"----------existingBlock END ------");

};

void (^vv)(void) = ^{

NSLog(@"----------vv START ------");

existingBlock();

NSLog(@"changing content of string object");

[ptrToStrObj replaceCharactersInRange:NSMakeRange(0, 8) withString:@"HA DO KEN!"];

NSLog(@"vv - address of POINTER ptrToStrObj......%p", &ptrToStrObj);

NSLog(@"existingBlock - address of OBJECT......%p", ptrToStrObj);

NSLog(@"existingBlock - %@", ptrToStrObj);

NSLog(@"----------vv END ------");

};

NSLog(@"Stack: &x: %p, %u \n", &x0, x0);

NSLog(@"Stack: &x: %p, %u \n", &x1, x1);

NSLog(@"------- on main thread -------\n");

vv();

dispatch_async(dispatch_get_global_queue(0, 0), ^{

NSLog(@"THREAD 2 start");

assert(vv);

sleep(1);

vv();

NSLog(@"in dispatch_async block - address of POINTER ptrToStrObj......%p", &ptrToStrObj);

NSLog(@"existingBlock - %@", ptrToStrObj);

NSLog(@"existingBlock - address of OBJECT......%p", ptrToStrObj);

NSLog(@"THREAD 2 done");

});

}

int main(int argc, const char * argv[])

{

@autoreleasepool {

foo(1);

sleep(2);

}

return 0;

}

output:

LOCAL – address of POINTER ptrToStrObj……0x7fff5fbff7e8
LOCAL – address of NSString object on heap……0x100211f00
Stack: &x: 0x7fff5fbff7f8, 1
Stack: &x: 0x7fff5fbff7f4, 2
——- on main thread ——-
———-vv START ——
existingBlock – address of POINTER ptrToStrObj……0x1001001e0
existingBlock – address of OBJECT……0x100211f00
existingBlock – ricky tsao, dob 6680
———-existingBlock END ——
changing content of string object
vv – address of POINTER ptrToStrObj……0x100300378
existingBlock – address of OBJECT……0x100211f00
existingBlock – HA DO KEN!ao, dob 6680
———-vv END ——
THREAD 2 start
———-vv START ——
———-existingBlock START ——
existingBlock – address of POINTER ptrToStrObj……0x1001001e0
existingBlock – address of OBJECT……0x100211f00
existingBlock – HA DO KEN!ao, dob 6680
———-existingBlock END ——
changing content of string object
vv – address of POINTER ptrToStrObj……0x100300378
existingBlock – address of OBJECT……0x100211f00
existingBlock – HA DO KEN!N!ao, dob 6680
———-vv END ——
in dispatch_async block – address of POINTER ptrToStrObj……0x100300168
existingBlock – HA DO KEN!N!ao, dob 6680
existingBlock – address of OBJECT……0x100211f00
THREAD 2 done

More Examples

GCD: dispatch_async

Contrary to what’s usually believed, dispatch_async per se will NOT cause a retain cycle

dispatch_async(queue, {

self.doSomething();

});

Here, the closure has a strong reference to self, but the instance of the class (self) does not have any strong reference to the closure, so as soon as the closure ends, it will be released, and so no cycle will be created. However, sometimes it’s (incorrectly) assumed that this situation will lead to a retain cycle.

Syntax

Blocks are declared like so:

NSString *(^getFullCarName)(NSString *) = ^(NSString *model) {

};

..and used like so:

1	NSLog(@"%@", getFullCarName(@"Accord"));

This example declares a variable called simpleBlock to refer to a block that takes no arguments and doesn’t return a value

void (^simpleBlock)(void);

simpleBlock = ^{

NSLog(@"This is a block");

};

You can also combine the variable assignment, and definition:

void (^simpleBlock)(void) = ^{

NSLog(@"This is a block");

};

Another Example

1	- (void)beginTaskWithCallbackBlock:(void (^)(void))callbackBlock;

The (void (^)(void)) specifies that the parameter is a block that doesn’t take any arguments or return any values. The implementation of the method can invoke the block in the usual way:

- (void)beginTaskWithCallbackBlock:(void (^)(void))callbackBlock {

...

callbackBlock();

}

Method parameters that expect a block with one or more arguments are specified in the same way as with a block variable:

- (void)doSomethingWithBlock:(void (^)(double, double))block {

...

block(21.0, 2.0);

}

it expects a block that does not return anything. But takes in double as the first 2 parameters.

Retain Cycle in iOS

September 7, 2015iOSadmin

ref – http://blog.reigndesign.com/blog/debugging-retain-cycles-in-objective-c-four-likely-culprits/
http://stackoverflow.com/questions/15266367/why-isn-t-my-weak-reference-cleared-right-after-the-strong-ones-are-gone?rq=1
http://www.quora.com/Objective-C-programming-language/What-is-the-difference-between-a-strong-and-weak-pointer

Pointers are automatically created with strong references; they are automatically retained. In this case, the strong keyword is implied when creating pointers, though you can use it if you want.

1 2	@property (strong, nonatomic) YonoCarouselView * carouselView; @property (nonatomic) YonoRSDFView * calendarView; //automatically implied that its strong

However there are times when you don’t want to retain an object (i.e. increase its reference count). To do this, you use the weak keyword when creating the pointer. Your pointer will still point to the object, but if that object is destroyed then using the pointer will cause a program error.

Note: In Objective-C every object has a reference count (i.e. the number of strong references to the object). i.e alloc, retain, new, dot retain,

In our case below, strongPtr points to newly allocated NSString object. Then it points away to another newly allocated NSString object. the original NSString object “myTestText” has no one pointing to it, even though it exists in memory because it does have a retain count of 1. Its just hanging out in memory space. Thus, ARC will either send a release or auto-release to it.

If ARC send release, weakPtr will display nil. If auto-release, then weakPtr may still display the address of the “myTestText”:

__strong NSString* strongPtr;

__weak NSString* weakPtr;

@autoreleasepool {

//NSString now have retain count of 2, alloc, and from __string

strongPtr = [[NSString alloc] initWithFormat:@"mYTeSTteXt %d", 3];

// weak pointer point to object create above (there is still strong ref to this obj)

weakPtr = strongPtr;

if(strongPtr == weakPtr) NSLog(@"They are pointing to the same obj");

NSLog(@"StrongPtr: %@", strongPtr);

NSLog(@"weakPtr: %@", weakPtr);

NSLog(@"Setting myText to different obj or nil");

// after line below, there is no strong referecene to the created object:

strongPtr = [[NSString alloc] initWithString:@"abc"];

}

if(strongPtr == weakPtr)

NSLog(@"Are the same");

else

NSLog(@"Are NOT the same");

NSLog(@"StrongPtr: %@", strongPtr);

// Why weak pointer does not point to nul

NSLog(@"weakPtr: %@", weakPtr);

1	@property (weak, nonatomic) YourClass * aVariable;

Strong variables will retain the value they point to.
Weak variables won’t retain their value and when the value is deallocated they will set their pointer to nil (to be safe).
Unsafe unretained values (as you probably can read by the name) won’t retain the value and if it gets deallocated they do nothing about it, potentially pointing to a bad piece of memory

When you’re working with garbage collection (10.5+), a weak reference is created by prefixing a variable declaration with __weak. When you assign to that variable, the GC (if enabled) keeps track of the reference and will zero it out for you automatically if all strong references to the referenced object disappear. (If GC is not enabled, the __weak attribute is ignored.)

Thus, you can safely modify the above answer to play nicer with garbage collection (currently on 10.5+, and perhaps someday on iPhone) as follows: (See the related Apple docs.)

@property (nonatomic,assign) __weak Row *yCoord;

To quote Chris Hanson (where you can find more detailed information):

“By prefixing an instance variable declaration with __weak, you tell the garbage collector that if it’s the only reference to an object that the object should be considered collectable.”

I’d clarify that by saying “if there are no non-weak references to an object”. As soon as the last strong reference is removed, the object may be collected, and all weak references will be zeroed automatically.

Note: This isn’t directly related to creating weak references, but there is also a __strong attribute, but since Objective-C object variables are strong references by default, it is generally used only for raw C pointers to things like structs or primitives that the Garbage Collector will not treat as roots, and will be collected from under you if you don’t declare them as strong. (Whereas the lack of __weak can cause retain cycles and memory leaks, the lack of __strong can result in memory stomping and really strange and insidious bugs that occur non-deterministically and can be quite difficult to track down.)

Why would you use a weak reference?

Well, one reason is if you have objects in parent-child relationships where the parent keeps pointers to its children and every child keeps a pointer to its parent. The potential with this structure is that you could no longer need your parent object and XCode will implicitly release it, but because its children keep a reference to it, the parent and its children can remain in memory even though you no longer have a way of accessing them. This is called a retain cycle.

To avoid the retain cycle, the children objects should only maintain a weak pointer to their parents. The reason for this is that when the parent is told to destroy itself, the children would be destroyed first so there is no chance they could access their parent after it had been destroyed.

NSTimer

If you create an NSTimer object on a view controller, be sure that invalidate is called on it when dismissing the view controller, otherwise it will retain self.

Observers/NSNotificationCenter

If you add an observer to NSNotificationCenter, make sure you remove all observers when dismissing the view controller, otherwise they will retain self.

Blocks

You should not call [self doSomething] from inside a block, this can easily lead to the block capturing a reference to self. Instead, make a weak reference to self:

BAD:

dispatch_async(queue, ^{

[self doSomething];

});

GOOD

__weak MyViewController *safeSelf = self;

dispatch_async(queue, ^{

[safeSelf doSomething];

});

Delegates

if you use

1	someObj.delegate = self;

inside the view controller, check the delegate property on someObj is weak.

1	@property (nonatomic, weak) id delegate;

Once you’ve made your fixes, check that dealloc is getting hit and the allocations no longer increase endlessly.

saving images from server onto ios client

September 5, 2015iOSadmin

http://stackoverflow.com/questions/6238139/ios-download-and-save-image-inside-app

when to use dispatch_sync

August 1, 2015iOSadmin

reference
http://stackoverflow.com/questions/4607125/using-dispatch-sync-in-grand-central-dispatch
http://stackoverflow.com/questions/9471420/whats-the-benefit-of-using-dispatch-sync-if-it-has-to-wait-until-the-main-threa?lq=1

First, let’s look at dispatch_async

//Do something

dispatch_async(queue, ^{

//Do something else

});

//Do More Stuff

You use dispatch_async to create a new thread. When you do that, the current thread will not stop.

That means:

Do More Stuff may be executed before Do something else finish.

What happens if you want the current thread to stop

You do not use dispatch at all. Just write the code normally

//Do something
//Do something else
//Do More Stuff

Now, say you want to do something on a DIFFERENT thread and yet wait as if and ensure that stuffs are done consecutively.

There are many reason to do this. UI update, for example, is done on main thread.

That’s where you use dispatch_sync

//Do something
dispatch_sync(queue, ^{
//Do something else
});
//Do More Stuff

Here you got

Do something
Do something else
Do More stuff done consecutively

…..even though //Do something else is done on a different thread.

Usually, when people use different thread, the whole purpose is so that something can get executed without waiting.

An Example of using Dispatch_Sync

Say we have a mutable array.

We then create a custom queue q in order to take tasks to execute.

We throw some blocks on this custom queue q and process it via asynchronously via dispatch_async.

Now, say, we want to pull the first item off of the array. Then shift all the items over 1 spot to fill in the empty space. Hence, we’re rearranging all this data on the array….we can’t be letting other threads touch this array (i.e adding, deleting, updating…etc)

We gotta stop all activities on the queue that’s adding stuff to our array. That queue is q so we gotta synchronous on it.

We take off the 1st item like so:

if ([a count] > 0) { // ...are all executed together...

first = [a objectAtIndex:0]; // ...as part of a single block...

[a removeObjectAtIndex:0]; // ...to ensure consistent results

}

We sync our taking off the 1st item with the other tasks in the queue. In other words, we make other tasks wait, execute taking off the 1st item, and let others continue.

Thus, this is an example of why we use dispatch_sync. We when we use sync, we block all other tasks on that queue. Let us finish our block. Then let the other tasks on that queue continue.

NSMutableArray *a = [[NSMutableArray alloc] init];

// All access to `a` is via this dispatch queue!

dispatch_queue_t q = dispatch_queue_create("com.foo.samplequeue", NULL);

dispatch_async(q, ^{ [a addObject:something]; }); // append to array, non-blocking

__block Something *first = nil; // "__block" to make results from block available

dispatch_sync(q, ^{ // note that these 3 statements...

if ([a count] > 0) { // ...are all executed together...

first = [a objectAtIndex:0]; // ...as part of a single block...

[a removeObjectAtIndex:0]; // ...to ensure consistent results

}

});

One More!

dispatch_sync does what you think — it posts the block to the nominated queue and blocks the current queue until the block has been performed. The main queue/thread isn’t specifically involved unless you’re either dispatching to it or from it.

So, you’d generally use it if an operation had to be performed on a different queue/thread — such as a SQLite or OpenGL operation — but you either needed the result of the operation or simply needed to know that the operation was complete for functionality terms.

The pattern:

dispatch_async(otherQueue,

id result = doHardTask();

dispatch_async(originalQueue,

didGetResult(result);

});

is better practice but isn’t really something you can just glue on at the end.

app performance

August 1, 2015iOSperformanceadmin

http://www.touchwonders.com/blog/how-to-make-your-apps-feel-responsive-and-fast-part-2

pushviewcontroller animations

July 29, 2015iOSadmin

ref – http://stackoverflow.com/questions/3838219/showing-pushviewcontroller-animation-look-like-presentmodalviewcontroller

@dynamic

July 28, 2015iOSadmin

Definitions

@synthesize will generate the getter and setter methods of the properties if the getter and/or setter has not already been implemented manually. This is what you currently believe @dynamic does.

@dynamic is used when you don’t want the runtime to automatically generate a getter and setter AND you haven’t implemented them manually. Basically, @dynamic is telling the compiler that the getter/setter will be provided dynamically at runtime or provided elsewhere, like a base class.

Usage

Since @dynamic means that the getter and setter methods are implemented elsewhere. One of the ways is to have runtime look for them in a Base class.

For example, say we have a Base class, and we implement the getter/setter methods like so:

@implementation Base

//property (self.publicAge), hence the iVar is _publicAge

@synthesize publicAge = _publicAge;

//property (self.publicName) uses publicName, hence iVar would be _publicName

@synthesize publicName = _publicName;

When we use self.publicAge, we use the getter/setter properties generated by the compiler. If we want to manipulate the instance variable itself, we use _publicAge.

Same goes for publicName.

If we want to write our own customizable methods, we’d do:

//custom getter / setter

-(int)publicAge {

NSLog(@"Base.m - publicAge....called from %@", [self class]);

return _publicAge;

}

-(void)setPublicAge:(int)newAge{

NSLog(@"Base.m - setPublicAge...called from %@", [self class]);

_publicAge = newAge;

}

In which case we over-ride the get/set methods generated by the compiler with our own custom get set methods. Whether you want to use the generated or your own custom methods is both fine, depending on your needs.

Using @dynamic

Now this is where using @dynamic comes in.

Say you have a class Child1, which is derived from the Base class.

@dyanmic means the getter/setter methods are implemented by the self class, but somewhere else
like superclass (Base), or be provided at runtime.

@implementation Child1

@dynamic publicAge;

@dynamic publicName;

...

@end

Hence when you use the properties

1 2	int i = [child1 publicAge]; NSString * name = [child1 publicName];

they will use Base’s publicAge and publicName getter/setter methods.

lazy loading pattern using property and synthesize

July 28, 2015C/C++/Objective-C, iOSadmin

#import "MyClass.h"

@implementation MyClass

//_word is instance variable (ivar)

//word is used in self.word fashion for get/set

@synthesize word = _word;

//you can declare your own custom get/set method like so, which we call an "explicit definition"

//here is where we have our custom lazy load of ivar _word

- (NSString *)word {

if (_word == nil) {

_word = [NSString stringWithFormat:@"some word"];

}

return _word;

}

-(instancetype)init

{

if(self=[super init]) {

//WRONG, compiler will throw error

[word stringByAppendingString:@"aya"];

//access instance variable through synthesized or your own custom get/set methods

[self.word stringByAppendingString:@"6680"];

//access instance variable itself

[_word stringByAppendingString:@""];

}

return self;

}

@end

NSURLConnection and GCD

July 9, 2015iOSNSURLConnectionadmin

If you have a class that uses NSURLConnectionDataDelegate and does asynchronous work via the NSURLConnectionDataDelegate methods

- (void)connection:(NSURLConnection *)connection didReceiveResponse:(NSURLResponse *)response;

- (void)connection:(NSURLConnection *)connection didReceiveData:(NSData *)data;

- (void)connectionDidFinishLoading:(NSURLConnection *)connection;

....etc

do not pair it with GCD because it itself is a separate worker thread that does the connections for you. Hence use NSURLConnection async by itself.

If you use NSURLConnection sync version, then you can use it with GCD.

Passing array json to Server

July 7, 2015iOS, Node JSadmin

iOS client

#import "CreateUserConnection.h"

#import "FlowRange.h"

@interface CreateUserConnection () <NSURLConnectionDelegate>

{

}

@property (nonatomic, strong) NSMutableData *buffer;

@property (nonatomic, strong) NSURLConnection *connection;

//block that gets retained when posting to WS, then used when the connection is finished

@property (nonatomic, copy) OnUserCreatedCloud completed;

@property (nonatomic, copy) NSString * auth_token;

@property (nonatomic, copy) NSString * email;

@property (nonatomic, assign) NSString* userID;

@property (nonatomic, copy) NSString * jsonInputString;

@property (nonatomic, strong) NSDictionary * info;

@property (nonatomic, strong) NSDictionary * user;

@end

@implementation CreateUserConnection

#pragma mark - ------------- LifeCycle -------------

-(instancetype)initWithEmail:(NSString*)email andAuthToken:(NSString*)token andID:(NSString*)newID

{

if(self=[super init])

{

self.email = email;

self.auth_token = token;

self.userID = newID;

FlowRange * range = [[FlowRange alloc] initWithBeginDate:today andEndDate:today];

NSArray * array = [NSArray arrayWithObjects:[self stringFromNSDate:range.beginDate],

[self stringFromNSDate:range.endDate],

@"08-03-2015", @"08-10-2015",

nil];

//build an info object and convert to json

self.info = [NSDictionary dictionaryWithObjectsAndKeys:

self.email, @"name",

@"12345678", @"password",

array, @"flowDates",

nil];

NSError *error = nil;

//1st step

NSData *jsonInputData = [NSJSONSerialization

dataWithJSONObject:self.info

options:NSJSONWritingPrettyPrinted error:&error];

//2nd step

self.jsonInputString = [[NSString alloc]

initWithData:jsonInputData

encoding:NSUTF8StringEncoding];

}

return self;

}

Basically, as we’re constructing our dictionary, our key is flowDates. We use an array of strings as our value.

self.info = [NSDictionary dictionaryWithObjectsAndKeys:

self.email, @"name",

@"12345678", @"password",

array, @"flowDates",

nil];

Server side

The json packet comes to our server via the request object.

In the request object’s body, we use key flowDates to get the array of strings passed in from the iOS client. We loop through this flowDates array to get the strings.

While we loop, we create a temp object called flowDay with keys startDate and endDate, and enter the strings from the array flowDates as their value.

1 2	var flowDay = { startDate: req.body.flowDates[i] , endDate: req.body.flowDates[i+1] };

Then we push that object onto an empty array.

1	flowDaysArray.push(flowDay);

Finally, we use that array to create a new user:

// create a sample user

var nick = new User({

name: req.body.name,

password: req.body.password, //You would protect your passwords by hashing it.

admin: true,

flowDates: flowDaysArray

});

Server side code

app.post('/setup', function(req, res) {

console.log('POST parameter received, name is: ' + req.body.name);

var flowDaysArray = [];

//req.body.flowDates is an array of strings coming in

for ( var i = 0; i < req.body.flowDates.length; i+=2)

{

//create flowDates object, and put these strings in

var flowDay = { startDate: req.body.flowDates[i] ,

endDate: req.body.flowDates[i+1] };

console.log( i + ', flow start day is: ' + flowDay.startDate

+ ', flow end day is: ' + flowDay.endDate);

flowDaysArray.push(flowDay);

}

// create a sample user

var nick = new User({

name: req.body.name,

password: req.body.password, //You would protect your passwords by hashing it.

admin: true,

flowDates: flowDaysArray

});

// save the sample user

nick.save(function(err) {

try {

if (err) throw err;

console.log('User ' + req.body.name + ' saved successfully...!');

res.json({ success: true });

}

catch(err)

{

console.log(err);

}

});