My little heaven

Recovering a deleted App Name in Apple Store

2013-12-15T16:37:00.000-08:00

If you want to use a App Name in your new Apple Developer Account, which already used in your another apple account, even though the status is "Developer Removed From Sale". iTunes Connect will disallow you, the error message will be like "the app name you entered has already been used".

There is a solution based on the following link: http://hesh.am/2012/01/recovering-a-deleted-app-name-in-itunes-connect/

As long as you change your default language when you creating your new app, iTunes Connect will allow you to create a new app even they have the same name.

For example , change the default language from Australian English to English.

iOS Interview Questions

2013-11-27T21:25:00.000-08:00

From: http://www.raywenderlich.com/53962/ios-interview-questions

1. Explain method swizzling. When you would use it?

2.Take three objects: a grandparent, parent and child. The grandparent retains the parent, the parent retains the child and the child retains the parent. The grandparent releases the parent. Explain what happens.

3. What happens when you invoke a method on a nil pointer?

4. Give two separate and independent reasons why retainCount should never be used in shipping code.

5. Explain your process for tracing and fixing a memory leak.

6. Explain how an autorelease pool works at the runtime level.

7. When dealing with property declarations, what is the difference between atomic and non-atomic?

8. In C, how would you reverse a string as quickly as possible?

9. Which is faster: to iterate through an NSArray or an NSSet

10. Explain how code signing works.

11. What is posing in Objective-C?

12. List six instruments that are part of the standard.

13. What are the differences between copy and retain?

14. What is the difference between frames and bounds?

15. What happens when the following code executes? Ball *ball = [[[[Ball alloc] init] autorelease] autorelease];

16. List the five iOS app states.

17. Do you think this interview was a good representation of your skills as a developer?

Learning Python -- Part two

2013-10-03T03:03:00.000-07:00

1. Dictionary

dic = {'lilei':90,'lily':100,'sam':57, ''tom" :90}

for key in dic
print dic[key]

print dic.keys(), return all keys
dic.values(), return all values
dic.items(), return all element
dic.clear(), clear dic, dic become {}

del dic['tom'] , delete 'tom' in dic, del is the keyword

2. file

f = open(filename, mode), "r" read, "w" write
content = f.read(N) , read N bytes data
content = f.readline(), read one line
content = f.readlines(), read all the lines

f.write('I like apple'), write to file

f.close()

3. range(), enumerate(), zip()
S = 'abcdefghijk'
for i in range(0,len(S),2):
print S[i]

for (index,char) in enumerate(S):
print index
print char

ta =[1,2,3]
tb = [9,8,7]
tc = ['a','b','c']
for (a,b,c) in zip(ta,tb,tc)
print(a,b,c)

ta = [1,2,3]
tb = [9,8,7]
zipped = zip(ta,tb)
print(zipped)

na,nb = zip(*zipped)
print(na,nb)

4. lambda
func = lambda x,y: x+ y
print func(3,4)

def teset(f,a,b):
print 'test'
print f(a,b)
test(func,3,5)

test((lambda x: x+3),[1,3,5,6])

5. map
re = map((lambda x,y: x+y),[1,2,3],[6,7,9])

6. filter
def func(a)
if a> 100:
return True
else:
return False

print filter(func,[10,56,101,500])

7. reduce
print reduce((lambda x,y: x+y),[1,2,5,7,9])

8. debug
re = iter(range(5))

try:
for i in range(100):
print re.next()
except StopIteration:
print 'Here is end ',i
print 'HaHaHa'

try:
...
except error1:
...
except error2:
...
else:
...
finally:
...

Learning Python - part one

2013-10-02T22:41:00.000-07:00

1. print 'Hello World'
a = 10
print a
print type(a)

a = 1.3
print a
print type(a)

basic type:
a = 10 int a =1.3 float a = True True/False a = 'Hello' string
type() - return data type

2. Sequence:
Tuple : s1 = (2, 1.3, 'love',9,12,false) , element can not be change

List: s2 = [True, 5, 'smile'] , element can change

print s1[0]
print s2[2]
s2[1] = 3.0
print s2

print s1[:5] -- from start to element 4
print s1[2:] -- from element 2 to last
print s1[0:5:2] -- from index 0 to element 4 , every 2 to get a element, such as element 0,2,4
print s1[2:0:-1] -- from element 2 to element 1

print s1[-1] -- last element
print s1[-3] -- the last third element

3. If else
i = 1
if i>0:
print 'positive i'
i = i+1
elif i ==0:
print 'i is 0'
i = i *10
else:
print 'negative i'
i = i -1
print 'new i:',i

4. for, while, continue, break

for a in [3,4.4, 'lift']:
print a

while i< 10:
print i
i = i+1

5. function
def square_sum(a,b)
c = a**2 + b ** 2
return c

print square_sum(3,4)

6. class , object
class Bird(object)
have_feather = True
way_of_reproduction = 'egg'
def move(self,dx,dy):
position =[0,0]
position[0] = position[0]+dx
position[1] = position[1] +dy
return position

summer = Bird()
print 'after move:', summer.move(5,8)

class Chicken(Bird):
way_of_move = 'walk'
possible_in_KFC = True

summer = Chicken()
print summer.have_feather
print summer.move(5,6)

7. dir(), help()
print dir(list)
print help(list)

n1 = [1,2,5,3,5]
n1.count(5), how many 5
n1.index(3), index of the first 3
n1.append(6), add 6 to the list
n1.sort(), sort
n1.pop(), remove the last element and return it
n1.remove(2), remove the first 2
n1.insert(0,9), insert 9 to position 0

iOS -- Core Image

2013-09-16T23:22:00.003-07:00

CIContext. All of the processing of a core image is done in a CIContext. This is somewhat similar to a Core Graphics or OpenGL context.
CIImage. This class hold the image data. It can be creating from a UIImage, from an image file, or from pixel data.
CIFilter. The filter class has a dictionary that defines the attributes of the particular filter that it represents. Examples of filters are vibrance filters, color inversion filters, cropping filters, and much more.

1.declare

@implementation ViewController

{

CIContext *context;

CIFilter *filter;

CIImage *beginImage;

}

2. change

NSString *filePath = [[NSBundle mainBundle]pathForResource:@"image" ofType:@"png"];

NSURL *fileNameAndPath = [NSURL fileURLWithPath:filePath];

beginImage = [CIImage imageWithContentsOfURL:fileNameAndPath];

context = [CIContext contextWithOptions:nil];

filter = [CIFilter filterWithName:@"CISepiaTone" keysAndValues:kCIInputImageKey,beginImage,@"inputIntensity",@0.8, nil];

CIImage *outputImage = [filter outputImage];

CGImageRef cgimg = [context createCGImage:outputImage fromRect:[outputImage extent]];

UIImage *newImage = [UIImage imageWithCGImage:cgimg];

self.imageView.image = newImage;

iOS - URL SCHEME

2013-09-15T23:18:00.000-07:00

To configure URL SCHEME

In Xcode project, info.

Open the app in code:

NSString *format = @"birdland://";

NSURL *url = [NSURL URLWithString:[NSString stringWithFormat:format]];

[[UIApplication sharedApplication] openURL:url];

iOS - KVO programming

2013-08-28T23:13:00.002-07:00

declare object:
interface StockData : NSObject {
NSString * stockName;
float price;
}
@end
@implementation StockData
@end

Add Observer:
[stockForKVO addObserver:self forKeyPath:@"price" options:NSKeyValueObservingOptionNew|NSKeyValueObservingOptionOld context:NULL];

Set Value:
myLabel.text = [stockForKVO valueForKey:@"price"];

Reset Value, trigger observer method:
[stockForKVO setValue:@"20.0" forKey:@"price"];

Call observer method:
-(void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
{
if([keyPath isEqualToString:@"price"])
{
myLabel.text = [stockForKVO valueForKey:@"price"];
}

}

Remove observer:
- (void)dealloc
{
[super dealloc];
[stockForKVO removeObserver:self forKeyPath:@"price"];
[stockForKVO release];
}

iOS- Notes for Predicates Programming Guide

2013-08-14T22:06:00.000-07:00

This is my notes for reading Apple Predicates Programming Guide

Reference: http://developer.apple.com/library/ios/DOCUMENTATION/Cocoa/Conceptual/Predicates/Articles/pUsing.html

Introduction to Predicates Programming Guide

A predicate is a logical operator that returns a Boolean value (true or false). There are two types of predicate;

comparison predicates, and compound predicates:
A comparison predicate compares two expressions using an operator.

A compound predicate compares the results of evaluating two or more other predicates, or negates
another predicate.

Predicate Classes
Cocoa provides three predicate classes: NSPredicate, and two subclasses of NSPredicate,

NSComparisonPredicate and NSCompoundPredicate.

Predicate expressions in Cocoa are represented by instances of NSExpression.

Creating Predicates
Creating a Predicate Using a Format String

NSPredicate *predicate = [NSPredicate
predicateWithFormat:@"(lastName like[cd] %@) AND (birthday > %@)",
lastNameSearchString, birthdaySearchDate];
(In the example, like[cd] means“case- and diacritic-insensitive like.”)

String Constants, Variables, and Wildcards
String constants must be quoted within the expression—single and double quotes are both acceptable, but must be paired appropriately

NSPredicate *predicate = [NSPredicate
predicateWithFormat:@"lastName like[c] \"S*\""];

You must take automatic quotation into account when using wildcards—you must add wildcards to a variable prior to substitution, as shown in the following example.

NSString *prefix = @"prefix";
NSString *suffix = @"suffix";
NSPredicate *predicate = [NSPredicate
predicateWithFormat:@"SELF like[c] %@",
[[prefix stringByAppendingString:@"*"] stringByAppendingString:suffix]];
BOOL ok = [predicate evaluateWithObject:@"prefixxxxxxsuffix"];

Boolean Values
NSPredicate *newPredicate =
[NSPredicate predicateWithFormat:@"anAttribute == %@", [NSNumber
numberWithBool:aBool]];
NSPredicate *testForTrue =
[NSPredicate predicateWithFormat:@"anAttribute == YES"];

Dynamic Property Names
Because string variables are surrounded by quotation marks when they are substituted into a format string using %@, you cannot use %@ to specify a dynamic property name—as illustrated in the following example.

NSString *attributeName = @"firstName";
NSString *attributeValue = @"Adam";
NSPredicate *predicate = [NSPredicate predicateWithFormat:@"%@ like %@",
attributeName, attributeValue];

The predicate format string in this case evaluates to "firstName" like "Adam".

If you want to specify a dynamic property name, you use %K in the format string, as shown in the following fragment.

predicate = [NSPredicate predicateWithFormat:@"%K like %@",
attributeName, attributeValue];

The predicate format string in this case evaluates to firstName like "Adam" (note that there are no
quotation marks around firstName).

Creating Predicates Directly in Code

NSComparisonPredicate and
NSCompoundPredicate provide convenience methods that allow you to easily create compound and
comparison predicates respectively. NSComparisonPredicate provides a number of operators ranging from simple equality tests to custom functions.

The following example shows how to create a predicate to represent (revenue >= 1000000) and (revenue < 100000000). Note that the same left-hand side expression is used for both comparison predicates.

NSExpression *lhs = [NSExpression expressionForKeyPath:@"revenue"];

NSExpression *greaterThanRhs = [NSExpression expressionForConstantValue:[NSNumber
numberWithInt:1000000]];
NSPredicate *greaterThanPredicate = [NSComparisonPredicate
predicateWithLeftExpression:lhs
rightExpression:greaterThanRhs
modifier:NSDirectPredicateModifier
type:NSGreaterThanOrEqualToPredicateOperatorType
options:0];

NSExpression *lessThanRhs = [NSExpression expressionForConstantValue:[NSNumber
numberWithInt:100000000]];
NSPredicate *lessThanPredicate = [NSComparisonPredicate
predicateWithLeftExpression:lhs
rightExpression:lessThanRhs
modifier:NSDirectPredicateModifier
type:NSLessThanPredicateOperatorType
options:0];

NSCompoundPredicate *predicate = [NSCompoundPredicate andPredicateWithSubpredicates:
@[greaterThanPredicate, lessThanPredicate]];

Creating Predicates Using Predicate Templates

NSPredicate *predicateTemplate = [NSPredicate
predicateWithFormat:@"lastName like[c] $LAST_NAME"];

To create a valid predicate to evaluate against an object, you use the NSPredicate method
predicateWithSubstitutionVariables: to pass in a dictionary that contains the variables to be
substituted. (Note that the dictionary must contain key-value pairs for all the variables specified in the predicate.)

NSPredicate *predicate = [predicateTemplate predicateWithSubstitutionVariables:
[NSDictionary dictionaryWithObject:@"Turner" forKey:@"LAST_NAME"]];

The new predicate returned by this example is lastName LIKE[c] "Turner

Because the substitution dictionary must contain key-value pairs for all the variables specified in the predicate, if you want to match a null value, you must provide a null value in the dictionary, as illustrated in the following example.

NSPredicate *predicate = [NSPredicate
predicateWithFormat:@"date = $DATE"];
predicate = [predicate predicateWithSubstitutionVariables:
[NSDictionary dictionaryWithObject:[NSNull null] forKey:@"DATE"]];

The predicate formed by this example is date ==

Format String Summary
@"attributeName == %@"
This predicate checks whether the value of the key attributeName isthe same asthe value of the object
%@ that is supplied at runtime as an argument to predicateWithFormat:. Note that %@ can be a
placeholder for any object whose description is valid in the predicate, such as an instance of NSDate,
NSNumber, NSDecimalNumber, or NSString.

@"%K == %@"
This predicate checks whether the value of the key %K is the same as the value of the object %@. The
variables are supplied at runtime as arguments to predicateWithFormat:.

@"%K == '%@'"
This predicate checks whether the value of the key %K is equal to the string literal “%@“ (note the single quotes around %@). The key name %K is supplied at runtime as an argument to predicateWithFormat:.

@"name IN $NAME_LIST"
This is a template for a predicate that checks whether the value of the key name is in the variable
$NAME_LIST (no quotes) that is supplied at runtime using predicateWithSubstitutionVariables:

@"'name' IN $NAME_LIST"
This is a template for a predicate that checks whether the constant value 'name' (note the quotes around
the string) is in the variable $NAME_LIST that is supplied at runtime using
predicateWithSubstitutionVariables:.

@"$name IN $NAME_LIST"
This is a template for a predicate that expects values to be substituted (using
predicateWithSubstitutionVariables:) for both $NAME and $NAME_LIST.

Using Predicates
Evaluating Predicates
To evaluate a predicate, you use the NSPredicate method evaluateWithObject: and pass in the object
against which the predicate will be evaluated. The method returns a Boolean value—in the following example,
the result is YES.

NSPredicate *predicate = [NSPredicate predicateWithFormat:@"SELF IN %@", @[@"Stig",
@"Shaffiq", @"Chris"]];
BOOL result = [predicate evaluateWithObject:@"Shaffiq"];

Using Predicates with Arrays
NSArray and NSMutableArray provide methods to filter array contents. NSArray provides
filteredArrayUsingPredicate: which returns a new array containing objects in the receiver that match
the specified predicate. NSMutableArray provides filterUsingPredicate: which evaluates the receiver’s
content against the specified predicate and leaves only objects that match.

NSMutableArray *array =
[NSMutableArray arrayWithObjects:@"Nick", @"Ben", @"Adam", @"Melissa", nil];
NSPredicate *bPredicate = [NSPredicate predicateWithFormat:@"SELF beginswith[c]
'a'"];
NSArray *beginWithB = [array filteredArrayUsingPredicate:bPredicate];
// beginWithB contains { @"Adam" }.
NSPredicate *sPredicate = [NSPredicate predicateWithFormat:@"SELF contains[c]
'e'"];
[array filterUsingPredicate:sPredicate];
// array now contains {@"Ben", @"Melissa" }

Using Predicates with Key-Paths
NSString *departmentName = ... ;
NSPredicate *predicate = [NSPredicate predicateWithFormat:
@"department.name like %@", departmentName];

If you use a to-many relationship, the construction of a predicate is slightly different. If you want to fetch Departments in which at least one of the employees has the first name "Matthew," for instance, you use an ANY operator as shown in the following example:

NSPredicate *predicate = [NSPredicate predicateWithFormat:
@"ANY employees.firstName like 'Matthew'"];

If you want to find Departments in which at least one of the employees is paid more than a certain amount, you use an ANY operator as shown in the following example:

float salary = ... ;
NSPredicate *predicate = [NSPredicate predicateWithFormat:@"ANY employees.salary
> %f", salary];

Null Values
A comparison predicate does not match any value with null except null (nil) or the NSNull null value (that is, ($value == nil) returns YES if $value is nil)

Testing for Null
If you want to match null values, you must include a specific test in addition to other comparisons, as illustrated in the following fragment.

predicate = [NSPredicate predicateWithFormat:@"(firstName == %@) || (firstName =
nil)", firstName];
filteredArray = [array filteredArrayUsingPredicate:predicate];
NSLog(@"filteredArray: %@", filteredArray);
// Output:
// filteredArray: ( { lastName = Turner; }, { birthday = 1972-03-23 20:45:32 -0800;
firstName = Ben; lastName = Ballard; }

By implication, a test for null that matches a null value returns true. In the following code fragment, ok is set to YES for both predicate evaluations.

predicate = [NSPredicate predicateWithFormat:@"firstName = nil"];
BOOL ok = [predicate evaluateWithObject:[NSDictionary dictionary]];
ok = [predicate evaluateWithObject:
[NSDictionary dictionaryWithObject:[NSNull null] forKey:@"firstName"]];

Using Predicates with Core Data
Fetch Requests
NSFetchRequest *request = [[NSFetchRequest alloc] init];
NSEntityDescription *entity = [NSEntityDescription entityForName:@"Employee"
inManagedObjectContext:managedObjectContext];
[request setEntity:entity];
NSNumber *salaryLimit = <#A number representing the limit#>;
NSPredicate *predicate = [NSPredicate predicateWithFormat:@"salary > %@",
salaryLimit];
[request setPredicate:predicate];
NSError *error;

NSArray *array = [managedObjectContext executeFetchRequest:request error:&error];

Regular Expressions
NSArray *array = @[@"TATACCATGGGCCATCATCATCATCATCATCATCATCATCATCACAG",
@"CGGGATCCCTATCAAGGCACCTCTTCG", @"CATGCCATGGATACCAACGAGTCCGAAC",
@"CAT", @"CATCATCATGTCT", @"DOG"];
// find strings that contain a repetition of at least 3 'CAT' sequences,
// but not followed by a further 'CA'
NSPredicate *catPredicate =
[NSPredicate predicateWithFormat:@"SELF MATCHES '.*(CAT){3,}(?!CA).*'"];
NSArray *filteredArray = [array filteredArrayUsingPredicate:catPredicate];
// filteredArray contains just 'CATCATCATGTCT'

According to the ICU specification, regular expression meta characters are not valid inside a pattern set. For example, the regular expression \d{9}[\dxX] does not match valid ISBN numbers (any ten digit number, or a string with nine digits and the letter 'X')since the pattern set ([\dxX]) contains a meta character (\d). Instead you could write an OR expression, as shown in the following code sample:

NSArray *isbnTestArray = @[@"123456789X", @"987654321x", @"1234567890", @"12345X",
@"1234567890X"];
NSPredicate *isbnPredicate =
[NSPredicate predicateWithFormat:@"SELF MATCHES '\\\\d{10}|\\\\d{9}[Xx]'"];
NSArray *isbnArray = [isbnTestArray filteredArrayUsingPredicate:isbnPredicate];
// isbnArray contains (123456789X, 987654321x, 1234567890)

Performance

NSPredicate *predicate = [NSPredicate predicateWithFormat:

@"( title matches .*mar[1-10] ) OR ( type = 1 )"];

you should write
NSPredicate *predicate = [NSPredicate predicateWithFormat:
@"( type = 1 ) OR ( title matches .*mar[1-10] )"];

In the second example, the regular expression is evaluated only if the first clause is false.

Predicate Format String Syntax
Parser Basics

Variables are denoted with a $ (for example $VARIABLE_NAME). ? is not a valid parser token.

%@ is a var arg substitution for an object value—often a string, number, or date.

%K is a var arg substitution for a key path.

When string variables are substituted into a format string using %@ , they are surrounded by quotation marks. If you want to specify a dynamic property name, use %K in the format string, as shown in the following example.

NSString *attributeName = @"firstName";
NSString *attributeValue = @"Adam";
NSPredicate *predicate = [NSPredicate predicateWithFormat:@"%K like %@",
attributeName, attributeValue];

The predicate format string in this case evaluates to firstName like "Adam“

Basic Comparisons
Boolean Value Predicates

TRUEPREDICATE
A predicate that always evaluates to TRUE.
FALSEPREDICATE
A predicate that always evaluates to FALSE.

String Comparisons
BEGINSWITH
The left-hand expression begins with the right-hand expression.

CONTAINS
The left-hand expression contains the right-hand expression.

ENDSWITH
The left-hand expression ends with the right-hand expression.

LIKE
The left hand expression equals the right-hand expression: ? and * are allowed as wildcard characters,
where ? matches 1 character and * matches 0 or more characters

MATCHES
The left hand expression equals the right hand expression using a regex-style comparison according to
ICU v3

Aggregate Operations
ANY, SOME

Specifies any of the elements in the following expression. For example ANY children.age < 18.

ALL

Specifies all of the elements in the following expression. For example ALL children.age < 18.

NONE
Specifies none of the elements in the following expression. For example, NONE children.age < 18.

This is logically equivalent to NOT (ANY ...).

IN
Equivalent to an SQL IN operation, the left-hand side must appear in the collection specified by the
right-hand side.
For example, name IN { 'Ben', 'Melissa', 'Nick' }. The collection may be an array, a set, or a
dictionary—in the case of a dictionary, its values are used.
In Objective-C, you could create a IN predicate as shown in the following example:

NSPredicate *inPredicate =
[NSPredicate predicateWithFormat: @"attribute IN %@", aCollection];

where aCollection may be an instance of NSArray, NSSet, NSDictionary, or of any of the
corresponding mutable classes.

Reserved Words

The following words are reserved:
AND, OR, IN, NOT, ALL, ANY, SOME, NONE, LIKE, CASEINSENSITIVE, CI, MATCHES, CONTAINS, BEGINSWITH,
ENDSWITH, BETWEEN, NULL, NIL, SELF, TRUE, YES, FALSE, NO, FIRST, LAST, SIZE, ANYKEY, SUBQUERY, CAST,

TRUEPREDICATE, FALSEPREDICATE

iOS- Create push notification private key by shell script

2013-08-06T23:38:00.000-07:00

To use the push notification, you need to create a p12 private key file to your server side. I would like to create a shell script for it. Then you can reuse it for some time.

First of all, you need to three source file :1.certSigningRequest, 2.p12(private key for the certificate), 3.cer(provision profile)

for example, using .Net to send push notification, you need to create a p12 file, you need to type 3 lines of command, which is

then you need to type the followinig command as below:

openssl x509 -in 3.cer -inform der -out PushCert.pem

openssl pkcs12 -nocerts -out PushKey.pem -in 2.p12

openssl pkcs12 -export -in PushCert.pem -inkey PushKey.pem -certfile 1.certSigningRequest -name "apn_production_identity" -out apn_production_identity.p12

Step one:

Open your terminal, type vim my_script

Step two:

input the following words:

#!/bin/bash

# Create push p12 file

openssl x509 -in 3.cer -inform der -out PushCert.pem

openssl pkcs12 -nocerts -out PushKey.pem -in 2.p12

openssl pkcs12 -export -in PushCert.pem -inkey PushKey.pem -certfile 1.certSigningRequest -name "apn_production_identity" -out apn_production_identity.p12

Step three:

save the file and put the source files and my_script in the same folder

Step four:

Open terminal, cd to the folder, run

bash my_script

After enter the password to verify, then you will get the p12 file, which is apn_production_identity.p12

iOS- NSString to NSDate and NSDate to NSString

2013-07-29T23:10:00.001-07:00

Here is the code snippet to show NSString convert to NSDate and NSDate convert to NSString

Input Date string and date formate

for example [aa dateFromString:@"your date" and @"dd/MM/yyyy hh:mm"];

+(NSDate*)dateFromString: (NSString*)dateString and: (NSString*)format

{

NSDateFormatter *dateformatter = [[NSDateFormatter alloc]init];

// Server sends Sydney time

NSTimeZone *zone = [NSTimeZone timeZoneWithName:@"Australia/Sydney"];

[dateformatter setTimeZone:zone];

// set locale, we use us date time style,
// if you want to force to display 12 hour style or 24 hour style, you can set en_US_POSIX force to use 12 hour style

NSLocale *locale = [[NSLocale alloc]initWithLocaleIdentifier:@"en_US"];

// date string to NSdate

[dateformatter setLocale:locale];

[dateformatter setDateFormat:format];

NSDate *date =[dateformatter dateFromString:dateString];

return date;

}

+(NSString*)stringFromDate: (NSDate*)date and: (NSString*)format

{

NSDateFormatter *dateFormat = [[NSDateFormatter alloc] init];

[dateFormat setDateFormat:format];

NSTimeZone *zone = [NSTimeZone localTimeZone];

[dateFormat setTimeZone:zone];

NSLocale *locale = [[NSLocale alloc]initWithLocaleIdentifier:@"en_US"];

[dateFormat setLocale:locale];

return [dateFormat stringFromDate:date];

}

Concurrency in iOS

2013-07-29T23:06:00.000-07:00

First of all, let's understand some basic concept:
Main queue
This queue performs all its tasks on the main thread, which is where Cocoa and Cocoa Touch require programmers to call all UI-related methods. Use the dispatch_get_main_queue function to retrieve the handle on the main queue.

Concurrent queues
These are queues that you can retrieve from GCD in order to execute asynchronous or synchronous tasks. Use the dispatch_get_global_queue function to retrieve the handle to a concurrent queue.

Serial queues
These are queues that, no matter whether you submit synchronous or asynchronous tasks to them, will always execute their tasks in the first-in-first-out(FIFO) fashion. Use the dispatch_queue_create to create a serial queue. Once you are done with the queue, you must release it using dispath_release function.

Only one main queue, but you can create as many serial dispatch queues as you want. Tasks can be handed to dispatch queues in two forms: block objects or C functions.

Main subjects to handle concurrency, Grand Central Dispatch, Threads,Timers,Operation and Operation Queues.

Grand Central Dispatch
Performing UI-Related Tasks with GCD

use dispatch_get_main_queue, UI-related tasks have to be performed on the main thread.
Code Snippet,

dispatch_queue_t mainQueue = dispatch_get_main_queue();

dispatch_async(mainQueue, ^(void) {
[[[UIAlertView alloc] initWithTitle:@"GCD" message:@"GCD is amazing!"

delegate:nil cancelButtonTitle:@"OK" otherButtonTitles:nil, nil] show];
});

Executing Non-UI Related Tasks Synchronously with GCD
use the dispatch_sync function

void (^printFrom1To1000)(void) = ^{
NSUInteger counter = 0; for (counter = 1;
counter <= 1000; counter++){
NSLog(@"Counter = %lu - Thread = %@", (unsigned long)counter,
[NSThread currentThread]);
} };

dispatch_queue_t concurrentQueue =dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_sync(concurrentQueue, printFrom1To1000);
dispatch_sync(concurrentQueue, printFrom1To1000);

The priority of the concurrent queue that GCD has to retrieve for the programmer.

DISPATCH_QUEUE_PRIORITY_LOW
Fewer timeslices will be applied to your task than normal tasks.

DISPATCH_QUEUE_PRIORITY_DEFAULT
The default system priority for the code execution will be applied to your task.

DISPATCH_QUEUE_PRIORITY_HIGH
More timeslices will be applied to your task than normal tasks.

Executing Non-UI Related Tasks Asychronously with GCD
Use dispatch_async

dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_async(concurrentQueue, ^{
__block UIImage *image = nil;
dispatch_sync(concurrentQueue, ^{ /* Download the image here */
});
dispatch_sync(dispatch_get_main_queue(), ^{

/* Show the image to the user here on the main queue*/

}); });

Performing Tasks After a Delay with GCD
use the dispatch_after and dispatch_after_f functions

double delayInSeconds = 2.0;
dispatch_time_t delayInNanoSeconds = dispatch_time(DISPATCH_TIME_NOW, delayInSeconds * NSEC_PER_SEC);

dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_after(delayInNanoSeconds, concurrentQueue, ^(void){ /* Perform your operations here */
});

Performing a Task Only Once with GCD
use the dispatch_once function

Core Data Programming Guide Notes -- Part 6

2013-07-19T04:34:00.001-07:00

This is the notes of Core Data Programing Guide from reading Apple's document

reference: http://developer.apple.com/library/ios/#DOCUMENTATION/Cocoa/Conceptual/CoreData/cdProgrammingGuide.html#//apple_ref/doc/uid/TP30001200-SW1

Core Data FAQ
Where does a Managed Object Context Come From?

Where a managed object context comes from is entirely application-dependent. In a Cocoa document-based application using NSPersistentDocument, the persistent document typically creates the context, and gives you access to it through the managedObjectContext method.

How do I initialize a store with default data?

There are two issues here: creating the data, and ensuring the data is imported only once.

There are several ways to create the data.

You can create a separate persistent store that contains the default data and include the store as an application resource. When you want to use it, you must either copy the whole store to a suitable location, or copy the objects from the defaults store to an existing store.
For small datasets, you can create the managed objects directly in code.
You can create a property list—or some other file-based representation—of the data, and store it as an application resource. When you want to use it, you must open the file and parse the representation to create managed objects.

How do I use my existing SQLite database with Core Data?

You don’t. Although Core Data supports SQLite as one of its persistent store types, the database format is private. You cannot create a SQLite database using native SQLite API and use it directly with Core Data (nor should you manipulate an existing Core Data SQLite store using native SQLite API). If you have an existing SQLite database, you need to import it into a Core Data store

How do I fetch objects in the same order I created them?

Objects in a persistent store are unordered. Typically you should impose order at the controller or view layer, based on an attribute such as creation date. If there is order inherent in your data, you need to explicitly model that.

Core Data Programming Guide Notes -- Part 5

2013-07-19T00:17:00.001-07:00

This is the notes of Core Data Programing Guide from reading Apple's document

reference: http://developer.apple.com/library/ios/#DOCUMENTATION/Cocoa/Conceptual/CoreData/cdProgrammingGuide.html#//apple_ref/doc/uid/TP30001200-SW1

Concurrency with Core Data

You can use threads, serial operation queues, or dispatch queues for concurrency. For the sake of conciseness, this article uses “thread” throughout to refer to any of these.

Use Thread Confinement to Support Concurrency

The pattern recommended for concurrent programming with Core Data is thread confinement : each thread must have its own entirely private managed object context.

There are two possible ways to adopt the pattern:

Create a separate managed object context for each thread and share a single persistent store coordinator.
This is the typically-recommended approach.

2.Create a separate managed object context and persistent store coordinator for each thread.

This approach provides for greater concurrency at the expense of greater complexity (particularly if you need to communicate changes between different contexts) and increased memory usage.

You must create the managed context on the thread on which it will be used. If you use NSOperation, note that its init method is invoked on the same thread as the caller. You must not, therefore, create a managed object context for the queue in the queue’s init method, otherwise it is associated with the caller’s thread. Instead, you should create the context in main (for a serial queue) or start (for a concurrent queue).

Using thread confinement, you should not pass managed objects or managed object contexts between threads. To “pass” a managed object from one context another across thread boundaries, you either:

Pass its object ID (objectID) and use objectWithID: or existingObjectWithID:error: on the receiving managed object context.

The corresponding managed objects must have been saved—you cannot pass the ID of a newly- inserted managed object to another context.

Execute a fetch on the receiving context.

Track Changes in Other Threads Using Notifications

Typically, on thread A you register for the managed object context save notification, NSManagedObjectContextDidSaveNotification. When you receive the notification, its user info dictionary contains arrays with the managed objects that were inserted, deleted, and updated on thread B. Because the managed objects are associated with a different thread, however, you should not access them directly. Instead, you pass the notification as an argument to mergeChangesFromContextDidSaveNotification: (which you send to the context on thread A). Using this method, the context is able to safely merge the changes.

Fetch in the Background for UI Responsiveness

Following the thread confinement pattern, you use two managed object contexts associated with a single persistent store coordinator. You fetch in one managed object context on a background thread, and pass the object IDs of the fetched objects to another thread. In the second thread (typically the application's main thread, so that you can then display the results), you use the second context to fault in objects with those object IDs (you use objectWithID: to instantiate the object). (This technique is only useful if you are using an SQLite store, since data from binary and XML stores is read into memory immediately on open.)

Saving in a Background Thread is Error-prone

If you perform a save operation in a background thread, therefore, it may be killed before it is able to complete. If you need to save on a background thread, you must write additional code such that the main thread prevents the application from quitting until all the save operation is complete.

If You Don’t Use Thread Containment

If you choose not to use the thread containment pattern—that is, if you try to pass managed objects or contexts between threads, and so on—you must be extremely careful about locking, and as a consequence you are likely to negate any benefit you may otherwise derive from multi-threading. You also need to consider that:

Any time you manipulate or access managed objects, you use the associated managed object context. Core Data does not present a situation where reads are “safe” but changes are “dangerous”—every operation is “dangerous” because every operation has cache coherency effects and can trigger faulting.
Managed objects themselves are not thread safe. If you want to work with a managed object across different threads, you must lock its context (seeNSLocking).

Typically you lock the context or coordinator using tryLock or lock. If you do this, the framework will ensure that what it does behind the scenes is also thread-safe. For example, if you create one context per thread, but all pointing to the same persistent store coordinator, Core Data takes care of accessing the coordinator in a thread-safe way (the lock and unlock methods of NSManagedObjectContext handle recursion).

If you lock (or successfully tryLock) a context, you must keep a strong reference to that context until you invoke unlock. If you don’t, in a multi-threaded environment, you may cause a deadlock.

Core Data Performance

Fetching Managed Objects

Fetch Predicates

How you use predicates can significantly affect the performance of your application.

Especially if the predicate involves text matching (contains, endsWith, like, and matches) since correct Unicode searching is slow. If the predicate combines textual and non-textual comparisons, then it is likely to be more efficient to specify the non-textual predicates first, for example (salary > 5000000) AND (lastName LIKE 'Quincey') is better than (lastName LIKE 'Quincey') AND (salary > 5000000).

Fetch Limits

You can set a limit to the number of objects a fetch will return using the method setFetchLimit: as shown in the following example.

NSFetchRequest *request = [[NSFetchRequest alloc]init];
[request setFetchLimit:100];

Faulting Behavior
You can safely invoke the following methods on a fault without causing it to fire: isEqual:, hash, superclass, class, self, zone, isProxy, isKindOfClass:, isMemberOfClass:, conformsToProtocol:, respondsToSelector:, description, managedObjectContext, entity, objectID, isInserted, isUpdated, isDeleted, and isFault.

Batch Faulting and Pre-fetching with the SQLite Store

When you execute a fetch, Core Data fetches just instances of the entity you specify.

Analyzing Performance

Analyzing Fetch Behavior with SQLite
With OS X version 10.4.3 and later, you can use the user default com.apple.CoreData.SQLDebug to log to stderr the actual SQL sent to SQLite. (Note that user default names are case sensitive.) For example, you can pass the following as an argument to the application:

-com.apple.CoreData.SQLDebug 1

Troubleshooting Core Data

Object Life-Cycle Problems

Merge errors

Problem: You see the error message, "Could not merge changes".
Cause: Two different managed object contexts tried to change the same data. This is also known as an optimistic
locking failure.
Remedy: Either set a merge policy on the context, or manually (programmatically) resolve the failure. You can retrieve the currently committed values for an object using committedValuesForKeys:, and you can re-fault the object (so that when it is next accessed its data values are retrieved from its persistent store) using refreshObject:mergeChanges:.

Assigning a managed object to a different store

Problem: You see an exception that looks similar to this example.

[_assignObject:toPersistentStore:]:

Can’t reassign an object to a different store once it has been saved.

Cause: The object you are trying to assign to a store has already been assigned and saved to a different store.
Remedy: To move an object from one store to another, you must create a new instance, copy the information

from the old object, save it to the appropriate store, and then delete the old instance.

Fault cannot be fulfilled

Problem: You see the error message, "Core Data could not fulfill a fault".

Cause: The corresponding object's underlying data has been deleted from the persistent store.
Remedy: You should discard this object.

This problem can occur in at least two situations:

First:

Start with a strong reference to a managed object.

Delete the managed object via the managed object context.

Save changes on the object context.

At this point, the deleted object has been turned into a fault. It isn’t destroyed because doing so would
violate the rules of memory management.

Try to retrieve an attribute or relationship from the previously retained reference.

Core Data will try to fault the faulted managed object but will fail to do so because the object has been deleted
from the store. That is, there is no longer an object with the same global ID in the store.

Second:

Delete an object from a managed object context.

Fail to break all relationships from other objects to that object.
Save changes.

Managed object invalidated

Problem: You see an exception that looks similar to this example:

[_assignObject:toPersistentStore:]:
The NSManagedObject with ID:#### has been invalidated.

Cause: Either you have removed the store for the fault you are attempting to fire, or the managed object's
context has been sent a reset message.

Remedy: You should discard this object. If you add the store again, you can try to fetch the object again.

Class is not key-value coding compliant

Problem: You see an exception that looks similar to the following example.

[ valueForUndefinedKey:]:
this class is not key value coding-compliant for the key randomKey.

Cause: Either you used an incorrect key, or you initialized your managed object with init instead of
initWithEntity:inManagedObjectContext:.

Remedy: Use a valid key (check the spelling and case carefully—also review the rules for key-value coding
compliance in Key-Value Coding Programming Guide ), or ensure that you use the designated initializer for
NSManagedObject (see initWithEntity:insertIntoManagedObjectContext:).

Efficiently Importing Data

Cocoa Fundamentals

Core Data Programming Guide Notes -- Part 4

2013-07-18T23:33:00.002-07:00

This is the notes of Core Data Programing Guide from reading Apple's document

reference: http://developer.apple.com/library/ios/#DOCUMENTATION/Cocoa/Conceptual/CoreData/cdProgrammingGuide.html#//apple_ref/doc/uid/TP30001200-SW1

Using Persistent Stores
Creating and Accessing a Store

Access to stores is mediated by an instance of NSPersistentStoreCoordinator. You should not need to directly access a file containing a store. From a persistent store coordinator, you can retrieve an object that represents a particular store on disk. Core Data provides an NSPersistentStore class to represent persistent stores.

To retrieve a store object from a coordinator, you use the method persistentStoreForURL:. You can use a store to restrict a fetch request to a specific store, as shown in the following code fragment:

Core Data and Cocoa Bindings

Note that Cocoa bindings are not available on iOS.

Change Management

Conflict Detection and Optimistic Locking

When Core Data fetches an object from a persistent store, it takes a snapshot of its state. A snapshot is a dictionary of an object’s persistent properties—typically all its attributes and the global IDs of any objects to which it has a to-one relationship.

If the values are the same, then the store has not been changed since the object was fetched, so the save proceeds normally. As part of the save operation, the snapshots' values are updated to match the saved data.

If the values differ, then the store has been changed since the object was fetched or last saved; this represents an optimistic locking failure.

Conflict Resolution

You can get an optimistic locking failure if more than one persistence stack references the same external data store (whether you have multiple persistence stacks in a single application or you have multiple applications).

The default behavior is defined by the NSErrorMergePolicy. This policy causes a save to fail if there are any merge conflicts.

In the case of failure, the save method returns with an error with a userInfo dictionary that contains the key @"conflictList";

The NSErrorMergePolicy is the only policy that generates an error. Other policies—NSMergeByPropertyStoreTrumpMergePolicy, NSMergeByPropertyObjectTrumpMergePolicy, and NSOverwriteMergePolicy—allow the save to proceed by merging the state of the edited objects with the state of the objects in the store in different ways. The NSRollbackMergePolicy discards in-memory state changes for objects in conflict and uses the persistent store’s version of the objects’ state.

Snapshot Management
An application that fetches hundreds of rows of data can build up a large cache of snapshots.

Responsibility for cleaning up snapshots rests with a mechanism called snapshot reference counting.

Communicating Changes Between Contexts
The following three strategies are presented in order of increasing complexity.

1.The simplest case is when the object itself has not changed in moc2 and you do not have to worry about undo; in this situation, you can just delete the object. The next time moc2 saves, the framework will notice that you are trying to re-delete an object, ignore the optimistic locking warning, and continue without error.

2.If you do not care about the contents of moc2, you can simply reset it (using reset) and refetch any data you need after the reset. This will reset the undo stack as well, and the deleted object is now gone. The only issue here is determining what data to refetch. You can do this by, before you reset, collecting the IDs (objectID) of the managed objects you still need and using those to reload once the reset has happened (you must exclude the deleted IDs, and it is best to create fetch requests with IN predicates to avoid problems will not being able to fulfill faults for deleted IDs).

3. If the object has changed in moc2, but you do not care about undo, your strategy depends on what it means for the semantics of your application. If the object that was deleted in moc1 has changes in moc2, should it be deleted from moc2 as well? Or should it be resurrected and the changes saved? What happens if the original deletion triggered a cascade delete for objects that have not been faulted into moc2? What if the object was deleted as part of a cascade delete?

There are two workable options (a third, unsatisfactory option is described later):

The simplest strategy is to just discard the changes by deleting the object.

Alternatively, if the object is standalone, you can set the merge policy on the context to NSMergePolicyOverwrite. This will cause the changes in the second context to overwrite the delete in the database.

Note that this will cause all changes in moc2 to overwrite any changes made in moc1.

Persistent Store Features
Store Types and Behaviors
Core Data provides three sorts of disk-based persistent store—XML, atomic, and SQLite—and an in-memory store.

iOS: The XML store is not available on iOS.

File Size May Not Reduce After Deleting a Record

Core Data Programming Guide Notes -- Part 3

2013-07-18T22:38:00.001-07:00

Object Lifetime Management

The Role of the Managed Object Context

his means that in general you cannot rely on a context to ensure the longevity of a managed object instance, and you cannot rely on the existence of a managed object to ensure the longevity of a context.

The exception to this rule is that a managed object context maintains a strong reference to any changed (inserted, deleted, and updated) objects until the pending transaction is committed (with a save:) or discarded (with a reset or rollback).

If you have finished with a managed object context, or for some other reason you want to “disconnect” a context from its persistent store coordinator, you should not set the context’s coordinator to nil:

// This will raise an exception
[myManagedObjectContext setPersistentStoreCoordinator:nil];

Instead, you should simply relinquish ownership of the context and allow it to be deallocated normally.

Breaking Relationship Strong Reference Cycles

To ensure that reference cycles are broken, when you're finished with an object you can use the managed object context method refreshObject:mergeChanges: to turn it into a fault.

Change and Undo Management

A context keeps strong references to managed objects that have pending changes (insertions, deletions, or updates) until the context is sent a save:, reset , rollback, or dealloc message, or the appropriate number of undos to undo the change.

The undo manager associated with a context keeps strong references to any changed managed objects.

Relationships and Fetched Properties

Core Data does not let you create relationships that cross stores. If you need to create a relationship from objects in one store to objects in another, you should consider using fetched properties.

Relationship Fundamentals

A relationship specifies the entity, or the parent entity, of the objects at the destination. This can be the same as the entity at the source (a reflexive relationship).

You can specify a relationship as being to-one or to-many. To-one relationships are represented by a reference to the destination object. To-many relationships are represented by mutable sets (although fetched properties are represented by arrays). Implicitly, “to-one” and “to-many” typically refer to “one-to-one” and “one-to-many” relationships respectively. A many-to-many relationship is one where a relationship and its inverse are both to-many.

You can also put upper and lower limits on the number of objects at the destination of a to-many relationship. The lower limit does not have to be zero. You can if you want specify that the number of employees in a department must lie between 3 and 40. You also specify a relationship as either optional or not optional. If a relationship is not optional, then in order to be valid there must be an object or objects at the destination of the relationship.

Relationship Delete Rules
A relationship's delete rule specifies what should happen if an attempt is made to delete the source object.

Deny
If there is at least one object at the relationship destination, then the source object cannot be deleted.

For example, if you want to remove a department, you must ensure that all the employees in that department are first transferred elsewhere (or fired!) otherwise the department cannot be deleted.

Nullify
Set the inverse relationship for objects at the destination to null.

For example, if you delete a department, set the department for all the current members to null. This only makes sense if the department relationship for an employee is optional, or if you ensure that you set a new department for each of the employees before the next save operation.

Cascade
Delete the objects at the destination of the relationship.

For example, if you delete a department, fire all the employees in that department at the same time.

No Action
Do nothing to the object at the destination of the relationship.

For example, if you delete a department, leave all the employees as they are, even if they still believe they belong to that department.

Manipulating Relationships and Object Graph Integrity

anEmployee.department = newDepartment;
Alternatively, you can use:

[newDepartment addEmployeeObject:anEmployee];

Many-to-Many Relationships

You must define many-to-many relationships in both directions—that is,you must specify two relationships, each being the inverse of the other. You can’t just define a to-many relationship in one direction and try to use it as a many-to-many. If you do, you will end up with referential integrity problems.

Unidirectional Relationships

in general, you should avoid using unidirectional relationships. Bidirectional relationships provide the framework with additional information with which to better maintain the object graph. If you do want to use unidirectional relationships, you need to do some of this maintenance yourself. In the case above, this would mean that after this line of code:

[managedObjectContext deleteObject:department];

you should write:
[employee setValue:nil forKey:@"department"];

Cross-Store Relationships

You must be careful not to create relationships from instances in one persistent store to instances in another persistent store, as this is not supported by Core Data. If you need to create a relationship between entities in different stores, you typically use fetched properties.

Fetched Properties
Fetched properties represent weak, one-way relationships.

A fetched property is like a relationship, but it differs in several important ways:

Rather than being a "direct" relationship, a fetched property's value is calculated using a fetch request. (The fetch request typically uses a predicate to constrain the result.)
A fetched property is represented by an array, not a set. The fetch request associated with the property can have a sort ordering, and thus the fetched property may be ordered.
A fetched property is evaluated lazily, and is subsequently cached.

You use refreshObject:mergeChanges: to manually refresh the properties—this causes the fetch request associated with this property to be executed again when the object fault is next fired.

There are two special variables you can use in the predicate of a fetched property—$FETCH_SOURCE and $FETCHED_PROPERTY.

Non-Standard Persistent Attributes

he principle behind the two approaches is the same: you present to consumers of your entity an attribute of the type you want, and “behind the scenes” it’s converted into a type that Core Data can manage.

Transformable Attributes

Managed Object Validation

There are two types of validation—property-level and inter-property. You use property-level validation to ensure the correctness of individual values; you use inter-property validation to ensure the correctness of combinations of values.

Core Data Validation
Cocoa provides a basic infrastructure for model value validation. It requires you, though, to write code for all the constraints you want to apply. Core Data allows you to put validation logic into the managed object model.

If you do want to customize validation of individual properties, you use standard validation methods as defined by the NSKeyValueCoding protocol

Property-Level Validation

The NSKeyValueCoding protocol specifies a method—validateValue:forKey:error:—that provides general support for validation methods in a similar way to that in which valueForKey: provides support for accessor methods.

If you want to implement logic in addition to the constraints you provide in the managed object model, you should not override validateValue:forKey:error:. Instead you should implement methods of the form validate:error:.

If you do implement custom validation methods, you should typically not invoke them directly. Instead you should call validateValue:forKey:error: with the appropriate key. This ensures that any constraints defined in the managed object model are also applied.
-(BOOL)validateAge:(id*)ioValue error:(NSError **)outError{}

The input value is a pointer to object reference (an id *). This means that in principle you can change the input value

Inter-Property validation
NSManagedObject provides additional loci for validation—update, insertion, and deletion—through the validateFor... methods such as validateForUpdate:.

Combining Validation Errors

Faulting and Uniquing

Faulting is a mechanism Core Data employs to reduce your application’s memory usage.

Faulting Limits the Size of the Object Graph

A fault is a placeholder object that represents a managed object that has not yet been fully realized, or a collection object that represents a relationship:

1. A managed object fault is an instance of the appropriate class, but its persistent variables are not yet initialized.
2. A relationship fault is a subclass of the collection class that represents the relationship.

To illustrate, consider an application that allows a user to fetch and edit details about a single employee. The employee has a relationship to a manager and to a department, and these objects in turn have other relationships. If you retrieve just a single Employee object from a persistent store, its manager, department, and reports relationships are initially represented by faults. Figure 1 shows an employee’s department relationship represented by a fault.

Fault handling is transparent—you do not have to execute a fetch to realize a fault.

If at some stage a persistent property of a fault object is accessed, then Core Data automatically retrieves the data for the object and initializes the object.

Firing Faults

Turning Objects into Faults

Turning a realized object into a fault can be useful in pruning the object graph.

Turning a managed object into a fault releases unnecessary memory, sets its in-memory property values to nil, and breaks strong references to related objects.

You can turn a realized object into a fault with the refreshObject:mergeChanges: method. If you pass NO as the mergeChanges argument, you must be sure that there are no changes to that object’s relationships.

When an object turns into a fault, it is sent a didTurnIntoFault message. You may implement a custom didTurnIntoFault method to perform various “housekeeping” function

Uniquing Ensures a Single Managed Object per Record per Context

Core Data ensures that—in a given managed object context—an entry in a persistent store is associated with only one managed object. The technique is known as uniquing.

For example, consider the situation illustrated in Figure 2; two employees have been fetched into a single managed object context . Each has a relationship to a department, but the department is currently represented by a fault.

It would appear that each employee has a separate department, and if you asked each employee for their department in turn—turning the faults into regular objects—you would have two separate Department objects in memory. However, if both employees belong to the same department (for example, "Marketing"), then Core Data ensures that (in a given managed object context) only one object representing the Marketing department is ever created. If both employees belong to the same department, their department relationships would both therefore reference the same fault

Core Data Programming Guide Notes -- Part 2

2013-07-18T17:43:00.001-07:00

Managed Objects

Basics
Managed objects are instances of the NSManagedObject class, or of a subclass of NSManagedObject, that represent instances of an entity. NSManagedObject is a generic class that implements all the basic behavior required of a managed object.

A managed object is also associated with a managed object context (“context”).

Custom Managed Object Classes

In combination with the entity description in the managed object model, NSManagedObject provides a rich set of default behaviors including support for arbitrary properties and value validation.

Object Life-Cycle—Initialization and Deallocation
Core Data “owns” the life-cycle of managed objects

The two other methods, awakeFromInsert and awakeFromFetch, allow you to differentiate between two different situations:

1.awakeFromInsert is invoked only once in the lifetime of an object—when it is first created.

2. awakeFromFetch is invoked when an object is re-initialized from a persistent store (during a fetch).

Validation

validateValue:forKey:error:

Managed Object Accessor Methods

You do need to write custom accessor methods if you use transient properties to support non-standard data types (see “Non-Standard Persistent Attributes” (page 91)) or if you use scalar instance variables to represent an attribute.

Custom implementation

NSManagedObject disables automatic key-value observing (KVO) change notifications for modeled properties, and the primitive accessor methods do not invoke the access and change notification methods.

Important: You are strongly encouraged to use dynamic properties (that is, properties whose implementation you specify as @dynamic) instead of creating custom implementations for standard or primitive accessor methods.

Creating and Deleting Managed Objects

Creating, Initializing, and Saving a Managed Object

in three main ways—a managed object:

Must be an instance of NSManagedObject or of a class that inherits from NSManagedObject

Exists in an environment defined by its managed object context

Has an associated entity description that describes the properties of the object

The following example shows the easiest way to create a new instance of an entity named “Employee”.

    NSManagedObject *newEmployee = [NSEntityDescription
    insertNewObjectForEntityForName:@"Employee"
    inManagedObjectContext:context];




The Managed Object Context 




The Entity Description





Given a managed object context, you could retrieve the appropriate entity description through the persistent
store coordinator as illustrated in the following example:






NSManagedObjectContext *context = <#Get a context#>;

NSManagedObjectModel *managedObjectModel =      
    [[context persistentStoreCoordinator] managedObjectModel];
NSEntityDescription *employeeEntity =



[[managedObjectModel entitiesByName] objectForKey:@"Employee"];




In practice, you would use the convenience method entityForName:inManagedObjectContext: of
NSEntityDescription which does the same thing—as illustrated in the following example:







NSManagedObjectContext *context = /* assume this exists */;
NSEntityDescription *employeeEntity = [NSEntityDescription

            entityForName:@"Employee"
            inManagedObjectContext:context];






















Creating a Managed Object







NSManagedObject *newEmployee = [[NSManagedObject alloc]
              initWithEntity:employeeEntity insertIntoManagedObjectContext:context];







Assigning an Object to a Store





Typically there is only one persistent store for a given entity, and Core Data automatically ensures that new objects are saved to this store when the object's managed object context is saved.





You specify the store for an object using the NSManagedObjectContext method,
assignObject:toPersistentStore:.




NSURL *storeURL = <#URL for path to global store#>;

id globalStore = [[context persistentStoreCoordinator]
    persistentStoreForURL:storeURL];

NSManagedObject *newEmployee = [NSEntityDescription
    insertNewObjectForEntityForName:@"Employee"
    inManagedObjectContext:context];

[context assignObject:newEmployee toPersistentStore:globalStore];





Of course, the object is not saved to the store until the managed object context is saved.        




Deleting a Managed Object




[aContext deleteObject:aManagedObject];





Relationships




When you delete a managed object it is important to consider its relationships and in particular the delete
rules specified for the relationships. If all of a managed object's relationship delete rules are Nullify, then for
that object at least there is no additional work to do (you may have to consider other objects that were at the
destination of the relationship—if the inverse relationship was either mandatory or had a lower limit on
cardinality, then the destination object or objects might be in an invalid state). If a relationship delete rule is
Cascade, then deleting one object may result in the deletion of others. If a rule is Deny, then before you delete
an object you must remove the destination object or objects from the relationship, otherwise you will get a
validation error when you save. If a delete rule is No Action, then you must ensure that you take whatever
steps are necessary to ensure the integrity of the object graph.





Fetching Managed Objects






Fetching Managed Objects





NSManagedObjectContext *moc = [self managedObjectContext];
  NSEntityDescription *entityDescription = [NSEntityDescription

      entityForName:@"Employee" inManagedObjectContext:moc];
  NSFetchRequest *request = [[NSFetchRequest alloc] init];
  [request setEntity:entityDescription];

  // Set example predicate and sort orderings...
  NSNumber *minimumSalary = ...;
  NSPredicate *predicate = [NSPredicate predicateWithFormat:

      @"(lastName LIKE[c] 'Worsley') AND (salary > %@)", minimumSalary];
  [request setPredicate:predicate];

  NSSortDescriptor *sortDescriptor = [[NSSortDescriptor alloc]
      initWithKey:@"firstName" ascending:YES];

  [request setSortDescriptors:@[sortDescriptor]];




  NSError *error;
  NSArray *array = [moc executeFetchRequest:request error:&error];
  if (array == nil)
  {    
      // Deal with error...
  }





The count of the array returned from the fetch will be 0 if the target object has been deleted. If you need to
test for the existence of several objects, it is more efficient to use the IN operator than it is to execute multiple
fetches for individual objects, for example:






NSPredicate *predicate = [NSPredicate predicateWithFormat:@"self IN %@",
                                            arrayOfManagedObjectIDs];





Fetching Specific Values





Sometimes you don’t want to fetch actual managed objects; instead, you just want to retrieve—for example—the
largest or smallest value of a particular attribute. In OS X v10.6 and later and on iOS, you can use
NSExpressionDescription to directly retrieve values that meet your criteria.




You create a fetch request object and set its entity, just as you would for a normal fetch, but:




You specify that the fetch should return dictionaries.     

You send the fetch request a setResultType: message with the argument NSDictionaryResultType.






You create instances of NSExpressionDescription to specify the properties you want to retrieve.


If you just want a single value—such as the largest salary in an Employee table—then you just create a
single expression description.





There are a number of steps to follow to create and use the expression description.     




First you need to create expressions (instances of NSExpression) to represent the key-path for the valueyou’re interested in, and to represent the function you want to apply (such as max: or min:):




NSExpression *keyPathExpression = [NSExpression    

     expressionForKeyPath:@"salary"];




 NSExpression *maxSalaryExpression = [NSExpression
     expressionForFunction:@"max: arguments:[NSArray   
     arrayWithObject:keyPathExpression]];     


     



You then create the expression description and set its name, expression, and result type.






NSExpressionDescription *expressionDescription = [[NSExpressionDescription
alloc] init];     

[expressionDescription setName:@"maxSalary"];
[expressionDescription setExpression:maxSalaryExpression];
[expressionDescription setExpressionResultType:NSDecimalAttributeType];





Finally, you set the request’s properties to fetch just the property represented by the expression:






[request setPropertiesToFetch:[NSArray
arrayWithObject:expressionDescription]];





Using Managed Objects







Accessing and Modifying Properties






NSString *firstName = [anEmployee firstName];
Employee *manager = anEmployee.manager;






newEmployee.firstName = @"Stig";
[newEmployee setManager:manager];




You can also use key-value coding (KVC) to get or set the value of a simple attribute as illustrated in the following
code fragment.






[newEmployee setValue:@"Stig" forKey:@"firstName"];      
[aDepartment setValue:[NSNumber numberWithInteger:100000]
forKeyPath:@"manager.salary"];





You must, however, change attribute values in a KVC-compliant fashion. For example, the following typically
represents a programming error:






NSMutableString *mutableString = [NSMutableString stringWithString:@"Stig"];
[newEmployee setFirstName:mutableString];
[mutableString setString:@"Laura"];


























     To-many relationships






      NSMutableSet *employees = [aDepartment mutableSetValueForKey:@"employees"];
[employees addObject:newEmployee];
[employees removeObject:firedEmployee];

// or
[aDepartment addEmployeesObject:newEmployee];
[aDepartment removeEmployeesObject:firedEmployee];



     [aDepartment.employees addObject:newEmployee]; // do not do this!   
then KVO change notifications are not emitted and the inverse relationship is not updated correctly.



     



Saving Changes


     




You can create and register managed objects with it, make changes to the objects,
and undo and redo changes as you wish. If you make changes to managed objects associated with a given
context, those changes remain local to that context until you commit the changes by sending the context a
save: message.


     




Managed Object IDs and URIs





     An NSManagedObjectID object is a universal identifier for a managed object, and provides basis for uniquing
in the Core Data Framework. A managed object ID uniquely identifies the same managed object both between
managed object contexts in a single application, and in multiple applications (as in distributed systems). 


     




NSManagedObjectID *moID = [managedObject objectID];







     There are two forms of an object ID. When a managed object is first created, Core Data assigns it a temporary
ID; only if it is saved to a persistent store does Core Data assign a managed object a permanent ID. You can readily discover whether an ID is temporary:



    



     BOOL isTemporary = [[managedObject objectID] isTemporaryID];





You can also transform an object ID into a URI representation:




     NSURL *moURI = [[managedObject objectID] URIRepresentation];




     Undo Management





     The Core Data framework provides automatic support for undo and redo. Undo management even extends
to transient properties (properties that are not saved to persistent store, but are specified in the managed
object model).





     Managed objects are associated with a managed object context. Each managed object context maintains an
undo manager. The context uses key-value observing to keep track of modifications to its registered objects.





     To undo an operation, you simply send the context an undo message and to redo it send the context a redo
message. You can also roll back all changes made since the last save operation using rollback (this also clears
the undo stack) and reset a context to its base state using reset.








      NSManagedObjectContext *moc = ...;
[moc processPendingChanges];  // flush operations for which you want undos
[[moc undoManager] disableUndoRegistration];
// make changes for which undo operations are not to be recorded
[moc processPendingChanges];  // flush operations for which you do not want undos
[[moc undoManager] enableUndoRegistration];





Faults







     NSString *managersName =[[anEmployee valueForKey:@"manager"] valueForKey:@"lastName];







     or more easily using key paths:





      NSString *managersName = [anEmployee valueForKeyPath:@"manager.lastName"];







     Ensuring Data Is Up-to-Date





     To refresh a managed object's property values, you use the managed object context method
refreshObject:mergeChanges:. If the mergeChanges flag is YES, the method merges the object's property
values with those of the object available in the persistent store coordinator; if the flag is NO, the method simply turns an object back into a fault without merging (which also causes strong references to other related managed objects to be broken, so you can use this method to trim the portion of your object graph you want to hold in memory).

Core Data Programming Guide Notes -- Part 1

2013-07-17T19:15:00.001-07:00

Why Should You Use Core Data?
50% to 70% smaller as measured by lines of code

Core Data has a mature code base whose quality is maintained

Core Data integrates well with the OS X tool chain

What Core Data Is Not
Core Data is not a relational database or a relational database management system (RDBMS).

Core Data is not a silver bullet.
Core Data does not rely on Cocoa bindings.

Basic Core Data Architecture

Managed Objects and Contexts

You can think of a managed object context as an intelligent scratch pad. When you fetch objects from a persistent store, you bring temporary copies onto the scratch pad where they form an object graph (or a collection of object graphs). You can then modify those objects however you like. Unless you actually save those changes, however, the persistent store remains unaltered.

Model objects that tie into in the Core Data framework are known as managed objects. All managed objects must be registered with a managed object context.

Fetch Requests

To retrieve data using a managed object context, you create a fetch request. A fetch request is an object that specifies what data you want, for example, “all Employees,” or “all Employees in the Marketing department ordered by salary, highest to lowest.”

Persistent Store Coordinator
Between managed object contexts and persistent object stores there is a persistent store coordinator.

Persistent Documents
The NSPersistentDocument class is a subclass of NSDocument that is designed to let you easily take advantage of the Core Data framework. By default, an NSPersistentDocument instance creates its own ready-to-use persistence stack, including a managed object context and a single persistent object store. There is in this case a one-to-one mapping between a document and an external data store.

Managed Objects and the Managed Object Model
A managed object model is a schema that provides a description of the managed objects, or entities, used by your application

Managed objects must be instances of either NSManagedObject or of a subclass of NSManagedObject. NSManagedObject is able to represent any entity.

Managed Object Models

he schema is represented by a managed object model—an instance of NSManagedObjectModel. In general, the richer the model, the better Core Data is able to support your application.

Features of a Managed Object Model

A managed object model is an instance of the NSManagedObjectModel class

Entities
A model contains NSEntityDescription objects that represent the model's entities. Two important features of an entity are its name, and the name of the class used to represent the entity at runtime.

Entity Inheritance

Abstract Entities
You can specify that an entity is abstract—that is, that you will not create any instances of that entity. You typically make an entity abstract if you have a number of entities that all represent specializations of (inherit from) a common entity which should not itself be instantiated

Properties
An entity's properties are its attributes and relationships, including its fetched properties (if it has any).

A property name cannot be the same as any no-parameter method name of NSObject or NSManagedObject—for example, you cannot give a property the name “description” (see NSPropertyDescription).

Attributes
Core Data natively supports a variety of attribute types, such as string, date, and integer (represented as instances of NSString, NSDate, and NSNumber respectively).

You can specify that an attribute is optional—that is, it is not required to have a value. In general, however, you are discouraged from doing so—especially for numeric values (typically you can get better results using a mandatory attribute with a default value—in the model—of 0). The reason for this is that SQL has special comparison behavior for NULL that is unlike Objective-C's nil. NULL in a database is not the same as 0, and searches for 0 will not match columns with NULL.

Relationships
Core Data supports to-one and to-many relationships, and fetched properties. Fetched properties represent weak, one-way relationships. I

Fetch Request Templates
You use the NSFetchRequest class to describe fetch requests to retrieve objects from a persistent store. It is often the case that you want to execute the same request on multiple occasions, or execute requests that follow a given pattern but which contain variable elements (typically supplied by the user). For example, you might want to be able to retrieve all publications written by a certain author, perhaps after a date specified by the user at runtime.

You can predefine fetch requests and store them in a managed object model as named templates. This allows you to pre-define queries that you can retrieve as necessary from the model. Typically, you define fetch request templates using the Xcode data modeling tool (see Xcode Tools for Core Data ). The template may include variables, as shown in Figure 2.

Configurations

A configuration has a name and an associated set of entities.

You typically use configurations if you want to store different entities in different stores. A persistent store coordinator can only have one managed object model, so by default each store associated with a given coordinator must contain the same entities.

Using a Managed Object Model

Creating and Loading a Managed Object Model

Managed Object Model means abc.xcdatamodeld

Compiling a Data Model

The model file is compiled using the model compiler, momc, to remove the extraneous information and make runtime loading of the resource as efficient as possible. An xcdatamodeld “source” directory is compiled into a momd deployment directory, and an xcdatamodel “source” file is compiled into a mom deployment file.

momc is located in /Developer/usr/bin/. If you want to use it in your own build scripts, its usage is momc source destination, where source is the path of the Core Data model to compile and destination is the path of the output.

Loading a Data Model

If you want to load a model yourself, there are two mechanisms you can use:

1.You can load a single model from a specific URL, using the instance method initWithContentsOfURL:.
2. You can create a merged model from a specific collection of bundles, using the class method mergedModelFromBundles:.

Problems May Arise if Your Project Contains More Than One Model

If you simply rename your model file, Core Data attempts to merge the current and the old versions and you get an error similar to the following:

reason = "'Can't merge models with two different entities named
'EntityName''";

If you create a new model that contains different entities from those in your original model, then Core Data merges the old and new models. If you have an existing store, you get an error similar to the following when you attempt to open it:

reason = "The model used to open the store is incompatible with the one
used to create the store";

There are two solutions:

1. Make sure that you clean any old build products before running the application. If the application bundle itself contains old model files, you can delete the application.

2. Instead of mergedModelFromBundles:, use initWithContentsOfURL: to initialize the model. The URL uniquely identifies a model so that Core Data will not merge the current model with any legacy models.

Changing the Schema Makes a Model Incompatible With Old Stores

If you add a new entity or a new attribute to an existing entity, you will not be able to open old stores; if you add a validation constraint or set a new default value for an attribute, you will be able to open old stores.

Important: Ifyouwanttochangethemodelbutalsoretaintheabilitytoopenstorescreatedusinga previous version of the model, you must keep the previous version of the model (as a version in a versioned model). Core Data cannot open a store for which it has no compatible model. Thus, if you want to change the model but also retain the ability to open existing stores, you must:

Ensure that you have a versioned model—if you don’t, make the current model into a versioned model.
Before editing the schema , create a new version of the current model.
Edit the new current version of the model, leaving the old version unaltered.

Accessing and Using a Managed Object Model at Runtime

Thus to get the model from a managed object context, you use the following code:
[[<#A managed object context#> persistentStoreCoordinator] managedObjectModel];

You can also retrieve the model from an entity description, so given a managed object you can retrieve its entity description and hence the model, as shown in the following example.
[[<#A managed object#> entity] managedObjectModel];

Creating Fetch Request Templates Programmatically

NSManagedObjectModel *model = <#Get a model#>;
NSFetchRequest *requestTemplate = [[NSFetchRequest alloc] init];
NSEntityDescription *publicationEntity =

    [[model entitiesByName] objectForKey:@"Publication"];
[requestTemplate setEntity:publicationEntity];

NSPredicate *predicateTemplate = [NSPredicate predicateWithFormat:
    @"(mainAuthor.firstName like[cd] $FIRST_NAME) AND \
        (mainAuthor.lastName like[cd] $LAST_NAME) AND \

        (publicationDate > $DATE)"];
[requestTemplate setPredicate:predicateTemplate];

[model setFetchRequestTemplate:requestTemplate
    forName:@"PublicationsForAuthorSinceDate"];

Accessing Fetch Request Templates

NSManagedObjectModel *model = <#Get a model#>;
NSError *error = nil;
NSDictionary *substitutionDictionary = [NSDictionary dictionaryWithObjectsAndKeys:

    @"Fiona", @"FIRST_NAME", @"Verde", @"LAST_NAME",

    [NSDate dateWithTimeIntervalSinceNow:-31356000], @"DATE", nil];
NSFetchRequest *fetchRequest =

    [model fetchRequestFromTemplateWithName:@"PublicationsForAuthorSinceDate"
            substitutionVariables:substitutionDictionary];

NSArray *results =

[aManagedObjectContext executeFetchRequest:fetchRequest error:&error];

Localizing a Managed Object Model
You localize a model by providing a localization dictionary that follows the pattern shown in the table below.

Key	Value	Note
"Entity/NonLocalizedEntityName"	"LocalizedEntityName"
"Property/NonLocalizedPropertyName/Entity/EntityName"	"LocalizedPropertyName"	1
"Property/NonLocalizedPropertyName"	"LocalizedPropertyName"

You can access the localization dictionary using the method localizationDictionary.

Strings File
The easiest way to localize a model is to create a corresponding strings file—the strings file name is the same as the model file name, but with a .strings rather than a .xcdatamodel extension

"Entity/Emp" = "Employee";
"Property/firstName" = "First Name";
"Property/lastName" = "Last Name";

"Property/salary" = "Salary";

Setting a Localization Dictionary Programmatically
You can set a localization dictionary at runtime using the NSManagedObjectModel method setLocalizationDictionary:

NSManagedObjectModel *mom = [[NSManagedObjectModel alloc] init];
NSEntityDescription *runEntity = [[NSEntityDescription alloc] init];
[runEntity setName:@"Run"];
[runEntity setManagedObjectClassName:@"Run"];

[mom setEntities:@[runEntity]];

NSMutableArray *runProperties = [NSMutableArray array];

NSAttributeDescription *dateAttribute = [[NSAttributeDescription alloc] init];
[runProperties addObject:dateAttribute];
[dateAttribute setName:@"date"];
[dateAttribute setAttributeType:NSDateAttributeType];

[dateAttribute setOptional:NO];

NSAttributeDescription *idAttribute= [[NSAttributeDescription alloc] init];
[runProperties addObject:idAttribute];
[idAttribute setName:@"processID"];
[idAttribute setAttributeType:NSInteger32AttributeType];

[idAttribute setOptional:NO];
[idAttribute setDefaultValue:@0];

NSPredicate *validationPredicate = [NSPredicate predicateWithFormat:@"SELF >= 0"]; NSString *validationWarning = @"Process ID < 0";
[idAttribute setValidationPredicates:@[validationPredicate]

    withValidationWarnings:@[validationWarning]];

[runEntity setProperties:runProperties];

NSDictionary *localizationDictionary = @{
    @"Property/processID/Entity/Run" : @"Process ID",
    @"Property/date/Entity/Run" : @"Date"
    @"ErrorString/Process ID < 0" : @"Process ID must not be less than 0" };

[mom setLocalizationDictionary:localizationDictionary];

iOS - set certain format to numbers

2013-07-10T22:31:00.000-07:00

If you have a number, like 123, but you want to display like 000123, you can do this like

NSString *transID =[NSString stringWithFormat:@"%06d",123];

Then it will fill up the empty space with 0

Ten iOS interview questions

2013-07-10T18:49:00.000-07:00

I had viewed some blogs, which mentioned ten iOS interview questions. I think it's basic but important. If you have 2-3 years iOS development experiments, you should answer the questions easily.

Ok, let's start.

1. Have you use objective-c runtime programming? If you did, what you use it for.

2. Have you use multi thread core data? which method you use? How do you do with NSPersistenStoreCoordinator,NsManagedObjectContext and NSManagedObject

3. Have you use CoreAnimation and COreGraphics. What is the relationship between UI framework, CA framework and CG framework.

4. Have you use CoreText or CoreImage? Tell me about that.

5. What is NSNotification and KVO? What's the difference between them? when to use NSNotification and when to use KVO? can you use protocol and delegate to implement the same function like NSNotification and KVO? why?

6. Have you use NSOperationQueue? Why you use NSOperationQueue and what for? Tell me about the difference between NSOperationQueue and GCD.

7. What you need to care when you use GCD and block? are they the same thing?

8. How to deal with Asynchronous Network? how do you implement that?

9. How do you think of Objective-C, pros and cons? Have you think about the redo some functions about Objective-C?

10. Have you implement a framework or library? If you do, tell me about that. If you do not, try to design a public API.

These questions might be too hard for junior iOS developer. If you need to answer all of that, maybe you at least have 2-3 years development experiments.

Reference:
http://onevcat.com/2013/04/ios-interview/
http://wufawei.com/2013/05/11-interview-questions/

iOS -- A new way to implement segment control

2013-06-02T22:00:00.000-07:00

Recently I have found a new way to implement segment control, wich is HMSegmentControl.

I found a very good project in GitHub, here is the link:

https://github.com/HeshamMegid/HMSegmentedControl

SQL -- Understand Index (Clustered vs. Non-Clustered index)

2013-05-30T22:57:00.001-07:00

Here is three articles to help you to understand Index in SQL.

–http://www.itbully.com/articles/sql-indexing-and-performance-part-2-clustered-and-non-clustered

–http://www.devtoolshed.com/content/clustered-index-vs-non-clustered-index-sql-server

–http://odetocode.com/articles/70.aspx

Xamarin -- Running .Net in Mac

2013-05-29T20:56:00.001-07:00

I just found a awesome IDE, Xamarin, which can run .Net project in Mac OS.

Here is the link:

http://monodevelop.com/Download

Add a Textfield in UIActionsheet

2013-04-20T03:37:00.001-07:00

If you want to add a UITextfield to a UIActionsheet in ios development, you can not just directly add the textfield to the actionsheet.

If you just add a textfield to actionsheet, you can not type any words in the textfield. It seems like some methods in textfield is not working properly.

So is it any way to add the textfield to actionsheet? The answer is yes.

Thanks to the following answer:

http://stackoverflow.com/questions/4367494/keypad-not-working-for-textfield-in-uiactionsheet

we can successfully add a textfield in actionsheet. The idea is show the actionsheet first, and then add the textfield above the actionsheet.

I just dont want to go through the detail. I have add the code to github. If you are looking for the solution about this. You can download it freely.

Here is the link:

https://github.com/fisherv1/actionsheetWithTextFiled.git

Here is what it looks like:

Ubuntu setup Git Server

2013-03-19T23:52:00.000-07:00

1. Setup

1.1 install Git-Core in Ubuntu server

sudo apt-get install git-core

1.2 install Gitosis in Ubuntu server

sudo apt-get install python-setuptools
mkdir ~/src
cd ~/src
git clone https://github.com/res0nat0r/gitosis.git
cd gitosis
sudo python setup.py install

2. Configuration

2.1 Enable ssh service in Ubuntu server

to use ssh-server, must open port 22 for
install ubuntu open ssh

sudo apt-get install openssh-server

to make sure ssh server enable or not, run ps -e | grep ssh

if only can see ssh-agent, means ssh-server not start yet, if see sshd means, ssh-server already start.

And then restart ssh server
run : sudo /etc/init.d/ssh restart

3. Add new user

3.1 cd to gitosis-admin

copy new user's id_rsa.pub to keydir folder, named as new_user.pub

3.2 edit gitosis.conf

vim gitosis.conf

edit as follow:

[group ProjectName]
members = old_user1 old_user2 new_user
writable = ProjectName

save and exit

3.3 back to gitosis-admin folder, push the change to server, then the sever will allow new member to download

git add .
git commit -am "add new user"
git push

Now the user can clone from the new user

4. Create new project

4.1 in local pc, open gitosis.conf, enter

[group NewProject]
members = matthewlu@mamembers = matthewlu@matthews-MacBook-Pro.local vic mac_mini
writable = NewProject

save and exit

push the change to server
git commit -am "create a new project"
git push

4.2 in server, in repositories folder , create a new folder
mkdir NewProject

cd to NewProject

Init a new git repository
git init --bare

4.3 in local machine

Create the NewProject

mkdir NewProject
git init
git remote add origin admin@YOURSERVER:NewProject
git add .
git commit -am "init a new project"
git push origin master

5. Create .gitignore for new create Xcode git project

5.1 touch .gitignore
The location of .gitignore is same as .git, .gitignore is not inside .git

5.2. vim .gitignore
add the content below to .gitignore

# Mac OS X
*.DS_Store

# Xcode
*.pbxuser
*.mode1v3
*.mode2v3
*.perspectivev3
*.xcuserstate
project.xcworkspace/
xcuserdata/

# Generated files
*.o
*.pyc

#Python modules
MANIFEST
dist/
build/

# Backup files
*~.nib

Then save and exit

5.3 add .gitignore to git

git add .gitignore
git commit -am "create .gitignore file"
git push origin master

6. Add ssh key to server

get the publick key key.pub

copy the key content to server authorzied_key

refresh ssh

7. gitignore file for visual studio

#

# Windows and Mac OS X Temp Cache Files

[Tt]humbs.db

*.DS_Store

#Visual Studio files

*.[Oo]bj

*.user

*.aps

*.pch

*.vspscc

*.vssscc

*_i.c

*_p.c

*.ncb

*.suo

*.tlb

*.tlh

*.bak

*.[Cc]ache

*.ilk

*.log

*.lib

*.sbr

*.sdf

ipch/

obj/

[Bb]in

[Dd]ebug*/

[Rr]elease*/

#Tooling

_ReSharper*/

*.resharper

[Tt]est[Rr]esult*

#Project files

[Bb]uild/

#Subversion files

.svn

# Microsoft Office Temp Files

~$*

# End of File

8. windows connect to ubuntu server
the path format is below:

192.168.1.26:repositories/EngagerIntranet.git

Converting Longitude and Latitude to a Meaningful Address

2013-03-18T15:45:00.003-07:00

This part of code is from Book , Vandad Nahavandipoor.

1. Declare a property of type CLGeocoder

#import

#import

@interface
Converting_Meaningful_Addresses_to_Longitude_and_LatitudeViewController : UIViewController
@property (nonatomic, strong) CLGeocoder *myGeocoder;
@end

2. In viewdidload

CLLocation *location = [[CLLocation alloc] initWithLatitude:+38.4112810

longitude:-122.8409780f]; self.myGeocoder = [[CLGeocoder alloc] init];
[self.myGeocoder
reverseGeocodeLocation:location completionHandler:^(NSArray *placemarks, NSError *error) {
if (error == nil && [placemarks count] > 0){
CLPlacemark *placemark = [placemarks objectAtIndex:0]; /* We received the results */
NSLog(@"Country = %@", placemark.country);
NSLog(@"Postal Code = %@", placemark.postalCode);
NSLog(@"Locality = %@", placemark.locality);
}
else if (error == nil &&
[placemarks count] == 0){ NSLog(@"No results were returned.");
}
else if (error != nil){
NSLog(@"An error occurred = %@", error); }
}];