Showing posts with label iOS. Show all posts
Showing posts with label iOS. Show all posts

How to Tame (and Improve) the iPhone’s Autocorrect Feature


Autocorrect is a really handy tool for those moments when you whiff the spelling of a complex word or transpose the letters in a simple one, but autocorrect errors can be extremely frustrating and the system isn’t without shortcomings. Read on as we show you how to whip your iPhone’s autocorrect system into shape (and teach it a new trick or two at the same time).

Why Do I Want To Do This?

When the autocorrect system in iOS is at the top of its game, it works beautifully and saves you from sending out texts with misspelled words. When you type “youre” it corrects to “you’re”, when you type “fihs” it corrects to “fish”; those and thousands of other slips-of-the-finger are all quickly and efficiently corrected so no one is the wiser to your punctuation and spelling follies.
When it’s malfunctioning or overly aggressive in its treatment of your text shorthand, slang, or even names it doesn’t recognize, it can get ugly fast. Your coworker’s uniquely spelled name becomes the name of a common household object. Your message goes from mundane to a triple entendre with a single flipped word. In fact there are entire websites, like the popular site Damn You Autocorrect, devoted to cataloging the mishaps and funny comments that result from overzealous text autocorrection.
Just because autocorrect is misbehaving, however, doesn’t mean you need to shut the whole system down. We’ve gathered together multiple tips and tricks here to help you wrestle your iPhone’s autocorrect system into shape.
Note: If you’re an Android user who wants to achieve the same ends for their Android phone, be sure to check out our similar article geared toward the Android OS here.

Add (And Remove) Autocorrect Entries

The best defense in autocorrection wrangling is a good offense. And the best offense when it comes to dealing with autocorrect is to aggressively manage the suggestions autocorrect throws at you. When the iPhone predictive text engine/autocorrect system latches onto a word it can be difficult (but not usually impossible) to get it to let go. It’s much easier to set it on the right path from the start.
Let’s say, for example, you want to teach autocorrect to accept the word “floofy”. This is not a dictionary approved word but a slang term that means very light, fluffy, or airy, and as such it’s a perfect way to demonstrate how autocorrect learns (and can unlearn) a word.  Let’s look at how autocorrect treats “floofy” if we actually made a typo versus if we wanted to teach autocorrect to accept it.
When you type the word “floofy” autocorrect assumes that you didn’t mean floofy but a similarly worded word like “floods”, as seen in the predictive text bar above. If you didn’t meant to type “floofy” and you really wanted to type “floods” then hit the spacebar and it will automatically correct the word to the best alternative in its dictionary (the best choice is always the center word in the suggestion bar).
If you did mean to type “floofy” you can select the quoted word “floofy”, as seen to the far left, in the suggestion bar above. This instructs the autocorrect system that you want the word (regardless of its dictionary status). Once you select the quoted text autocorrect will stop switching “floofy” to “floods”.
Don’t worry, if you accidentally add a word you don’t want to add, you can correct it in one of two ways. You can click on the word (as seen in the screenshot above) to prompt an alternative selection or you can backspace the entire word out and start again. After you’ve overwritten an entry a few times with the correct spelling autocorrect should accept the new spelling.
If for some reason selecting the alternative text or backspacing over the text to replace it with the correct spelling doesn’t fix your problem, you can use the trick in the next section to override autocorrect.

Add Shortcuts

Another clever trick to manipulate autocorrect (and to save yourself from typing long names or phrase too) is to take advantage of the shortcut function. The shortcut system could also be called a substitution system because the phone automatically substitutes the target word or phrase for the shortcut whenever you type it out.
Let’s say, for example, we wanted our iPhone to always type out the formal name of How-To Geek when we were texting but we didn’t actually want the hassle of writing three words, capitalizing them, and including the hyphen every single time. To that end we can create a simple substitution wherein “htg” is automatically substituted with “How-To Geek”.
Navigate to Settings -> General -> Keyboard on your iOS device and then select the Shortcuts entry.
By default iOS has one example shortcut “omw” for “On my way!” It’s easy enough to add another (or hundreds more depending on how motivated you are) by simply tapping on the + symbol in the upper right corner.

There you simply enter the phrase you want the shortcut to expand into (in this case “Allsoftlearn”) followed by the shortcut to trigger it (in this case “htg”).
Now when we type “htg” (seen above) on our iPhone it automatically expands into “Allsoftlearn” as soon as we hit the spacebar after the shortcut is entered (seen below).
Making life easy with text-expansion shortcuts isn’t the only thing you can do with the handy shortcut system. You can also use it to overrule autocorrect errors. Sometimes it becomes impossible (or nearly impossible) to overrule an autocorrect error despite your best efforts (such as force correcting autocorrect as we highlighted in the previous section of this article). In such cases you can overrule autocorrect with a shortcut entry. Let’s say, for example, you misspelled a common (but in your defense tricky!) word so many times that it screwed up the autocorrect entry and autocorrect now believes your misspelling is the right one.
If it’s only a problem with a few words you can easily create a shortcut entry to fix your autocorrect flub. If you mispelled anonymous wrong so many times that it now thinks the correct spelling is “anonamous” you just need to make a shortcut entry where the phrase is the correct spelling “anonymous” and the shortcut is also the correct spelling “anonymous”. Now when you type the word correctly, “anonymous”, despite the autocorrect entry being off the shortcuts menu will take precedence over the autocorrect entry and the word will be spelled as you entered it in the shortcut menu.
On a lighter note, the shortcuts menu is also a great way to prank somebody without actually screwing up their autocorrect system and in-phone dictionary. Let’s say you wanted to prank a coworker to have your boss’s name substitute out for another phrase. You could create an entry on your coworker’s phone for a shortcut that swaps “Steve”, the name of your boss, with “Sweetie”. Whether hilarity or an HR writeup would ensue is a matter of corporate climate and we’d advise you to use your new found powers wisely.

Add Unique Names To Your Contacts

Another area autocorrect struggles with is unique names. My name, Jason, is a very common Western name that autocorrect doesn’t even blink at. But what about the Jasyns of the world? While their parents might have liked the alternative spelling of Jason, the autocorrect editors of the world certainly don’t.
If you frequently text or email a person with a unique name or one that is not spelled in the conventional fashion autocorrect expects you could use the tricks in the two previous sections to teach autocorrect how to spell their name, but the most time-efficient way to deal with the specific problem of unique names is to simply create a contact for that person in your address book.
Autocorrect uses the name list in your address book as a reference presuming, correctly so, that you maintain contact with the people on that list and it should respect the spelling of their names. Even if you don’t plan on having direct contact with the person in question (let’s say you want autocorrect to respect the nickname spelling you use for a friend or your child) you can create an empty contact entry with just the (nick)name of the person in question, as seen in the screenshot above. Tap on the Phone icon, then Contacts -> + to add a new contact and trick autocorrect into respecting the spelling of their name.

Reset The Dictionary

If you’ve done your best to undo your autocorrect missteps using the tricks outlined above regarding setting (and overwriting) autocorrect entries but you just can’t seem to get the changes to stick, the final step to wiping the autocorrect slate clean is to reset the keyboard dictionary.
Navigate to Settings -> General -> Reset and tap on “Reset Keyboard Dictionary”. Tread carefully in this screen as it includes not only a link to reset the keyboard dictionary but links to reset your network settings, phone contents, and other significant parts of your phone. Confirm you want to reset the dictionary and it will be wiped back to the factory defaults.
This will erase any and all modifications you have made to the keyboard (like when we trained the dictionary to accept “floofy” in the first section) but it will not erase any shortcuts you created or contact list entry name/nicknames.

Disable Autocorrect (And Other Keyboard Tweaks)

If you’ve done your best to wrangle autocorrect and you’re just fed up with the whole affair you can, rather easily, completely disable it. To disable autocorrect navigate to Settings -> General -> Keyboard on your iOS device.
Under the Keyboard menu simply untick “Auto-Correction” and you’re done.

iOS - Accelerometer

Accelerometer is used for detecting the changes in the position of the device in the three directions x, y and z. We can know the current position of the device relative to the ground. For testing this example, you'll need to run it on a device and to doesn't work on simulator.

Accelerometer – Steps Involved

Step 1. Create a simple View based application.
Step 2. Add three labels in ViewController.xib and create ibOutlets naming them as xlabel, ylabel, and zlabel.
Step 3. Update ViewController.h as follows −
#import 

@interface ViewController : UIViewController<UIAccelerometerDelegate>
{
    IBOutlet UILabel *xlabel;
    IBOutlet UILabel *ylabel;
    IBOutlet UILabel *zlabel;

}
@end

Step 4. Update ViewController.m as follows −
#import "ViewController.h"

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad
{
    [super viewDidLoad];
    [[UIAccelerometer sharedAccelerometer]setDelegate:self];
    //Do any additional setup after loading the view,typically from a nib
}

- (void)didReceiveMemoryWarning
{
    [super didReceiveMemoryWarning];
    // Dispose of any resources that can be recreated.
}
- (void)accelerometer:(UIAccelerometer *)accelerometer didAccelerate:
  (UIAcceleration *)acceleration{
    [xlabel setText:[NSString stringWithFormat:@"%f",acceleration.x]];
    [ylabel setText:[NSString stringWithFormat:@"%f",acceleration.y]];
    [zlabel setText:[NSString stringWithFormat:@"%f",acceleration.z]];
}

@end

Output

When we run the application in iPhone device, we'll get the following output −



iOS - Objective C

The language used in iOS development is objective C. It is an object-oriented language and hence, it would be easy for those who have some background in object-oriented programming languages.

Interface and Implementation

In Objective C, the file where the declaration of class is done is called theinterface file and the file where the class is defined is called theimplementation file.
A simple interface file MyClass.h would look like the following −
@interface MyClass:NSObject{ 
// class variable declared here
}
// class properties declared here
// class methods and instance methods declared here
@end
The implementation file MyClass.m would be as follows −
@implementation MyClass
// class methods defined here
@end

Object Creation

Object creation is done as follows −
MyClass  *objectName = [[MyClass alloc]init] ;

Methods

Method is declared in Objective C as follows −
-(returnType)methodName:(typeName) variable1 :(typeName)variable2;
An example is shown below.
-(void)calculateAreaForRectangleWithLength:(CGfloat)length 
andBreadth:(CGfloat)breadth;
You might be wondering what the andBreadth string is for; actually it’s an optional string, which helps us read and understand the method easily, especially at the time of calling. To call this method in the same class, we use the following statement −
[self calculateAreaForRectangleWithLength:30 andBreadth:20];
As said above, the use of andBreadth helps us understand that breadth is 20. Self is used to specify that it's a class method.

Class Methods

Class methods can be accessed directly without creating objects for the class. They don't have any variables and objects associated with it. An example is shown below.
+(void)simpleClassMethod;
It can be accessed by using the class name (let's assume the class name as MyClass) as follows −
[MyClass simpleClassMethod];

Instance Methods

Instance methods can be accessed only after creating an object for the class. Memory is allocated to the instance variables. An example instance method is shown below.
-(void)simpleInstanceMethod; 
It can be accessed after creating an object for the class as follows −
MyClass  *objectName = [[MyClass alloc]init] ;
[objectName simpleInstanceMethod];

Important Data Types in Objective C

S.N.Data Type
1NSString
It is used for representing a string.
2CGfloat
It is used for representing a floating point value (normal float is also allowed but it's better to use CGfloat).
3NSInteger
It is used for representing integer.
4BOOL
It is used for representing Boolean (YES or NO are BOOL types allowed).

Printing Logs

NSLog - used for printing a statement. It will be printed in the device logs and debug console in release and debug modes respectively. For example,
NSlog(@"");

Control Structures

Most of the control structures are same as in C and C++, except for a few additions like for in statement.

Properties

For an external class to access the class, variable properties are used. For example,
@property(nonatomic , strong) NSString *myString;

Accessing Properties

You can use dot operator to access properties. To access the above property, we will do the following.
self.myString = @"Test";
You can also use the set method as follows −
[self setMyString:@"Test"];

Categories

Categories are used to add methods to the existing classes. By this way, we can add method to classes for which we don't have even implementation files where the actual class is defined. A sample category for our class is as follows −
@interface MyClass(customAdditions)
- (void)sampleCategoryMethod;
@end

@implementation MyClass(categoryAdditions)

-(void)sampleCategoryMethod{
   NSLog(@"Just a test category");
}

Arrays

NSMutableArray and NSArray are the array classes used in objective C. As the name suggests, the former is mutable and the latter is immutable. An example is shown below.
NSMutableArray *aMutableArray = [[NSMutableArray alloc]init];
[anArray addObject:@"firstobject"];
NSArray *aImmutableArray = [[NSArray alloc]
initWithObjects:@"firstObject",nil];

Dictionary

NSMutableDictionary and NSDictionary are the dictionary classes used in objective C. As the name suggests, the former is mutable and the latter is immutable. An example is shown below.
NSMutableDictionary*aMutableDictionary = [[NSMutableArray alloc]init];
[aMutableDictionary setObject:@"firstobject" forKey:@"aKey"];
NSDictionary*aImmutableDictionary= [[NSDictionary alloc]initWithObjects:[NSArray arrayWithObjects:
@"firstObject",nil] forKeys:[ NSArray arrayWithObjects:@"aKey"]];

iOS - Environment Setup

iOS - Xcode Installation

Step 1 − Download the latest version of Xcode 

Step 2 − Double click the Xcode dmg file.
Step 3 − You will find a device mounted and opened.
Step 4 − There will be two items in the window that's displayed namely, Xcode application and the Application folder's shortcut.
Step 5 − Drag the Xcode to application and it will be copied to your applications.
Step 6 − Now Xcode will be available as a part of other applications from which you can select and run.
You also have another option of downloading Xcode from the Mac App store and then install following the step-by-step procedure given on the screen.

Interface Builder

Interface builder is the tool that enables easy creation of UI interface. You have a rich set of UI elements that is developed for use. You just have to drag and drop into your UI view. We'll learn about adding UI elements, creating outlets and actions for the UI elements in the upcoming pages.

You have objects library at the right bottom that consists the entire necessary UI element. The user interface is often referred as xibs, which is its file extension. Each of the xibs is linked to a corresponding view controller.

iOS Simulator

An iOS simulator actually consists of two types of devices, namely iPhone and iPad with their different versions. iPhone versions include iPhone (normal), iPhone Retina, iPhone 5. iPad has iPad and iPad Retina. A screenshot of an iPhone simulator is displayed below.


You can simulate location in an iOS simulator for playing around with latitude and longitude effects of the app. You can also simulate memory warning and in-call status in the simulator. You can use the simulator for most purposes, however you cannot test device features like accelerometer. So, you might always need an iOS device to test all the scenarios of an application thoroughly.

iOS - First iPhone Application

Creating the First App

Now we are going to create a simple single view application (a blank app) that will run on the iOS simulator.
The steps are as follows.
Step 1 − Open Xcode and select Create a new Xcode project.


Step 2 − Select Single View Application.


Step 3 − Enter the product name, i.e., the name of the application, organization name, and then the company identifier.


Step 4 − Ensure that Use Automatic Reference Counting is selected in order to automatically release the resources allocated once it goes out of scope. Click Next.
Step 5 − Select the directory for the project and select create.


Step 6 − You will see a screen as follows −


In the screen above, you will be able to select the supported orientations, build and release settings. There is a field deployment target, the device version from which we want to support, lets select 4.3, which is the minimum deployment target allowed now. For now, these are not required and let's focus on running the application.
Step 7 − Now, select iPhone simulator in the drop down near Run button and select run.


Step 8 − That's it; you have successfully run your first application. You will get an output as follows −

Now let's change the background color, just to have a start with the interface builder. Select ViewController.xib. Select background option in the right side, change the color and run.


In the above project, by default, the deployment target would have been set to iOS 6.0 and auto-layout will be enabled. To ensure that our application runs on devices that are on iOS 4.3 onwards, we have already modified the deployment target at the start of creation of this application, but we didn't disable auto-layout.
To disable auto-layout, we need to deselect the auto-layout checkbox in the file inspector of each nib, i.e., the xib files. The various sections of Xcode project IDE are given in the following figure (Courtesy: Apple Xcode 4 User documentation).

File inspector is found in the inspector selector bar as shown above and auto layout can be unchecked there. Auto layout can be used when you want to target only iOS 6 devices. Also, you'll be able to use many new features like passbook if you raise the deployment target to iOS 6. For now, let's stick to iOS 4.3 as the deployment target.

Code of the First iOS Application

You will find five different files that would have been generated for your application. They are listed as follows −
  • AppDelegate.h
  • AppDelegate.m
  • ViewController.h
  • ViewController.m
  • ViewController.xib

AppDelegate.h

// Header File that provides all UI related items. 
#import  

 // Forward declaration (Used when class will be defined /imported in future)
@class ViewController;  

 // Interface for Appdelegate
@interface AppDelegate : UIResponder <UIApplicationDelegate>

// Property window 
@property (strong, nonatomic) UIWindow *window; 

 // Property Viewcontroller

 @property (strong, nonatomic) ViewController *viewController;
//this marks end of interface 
@end  
Important items in code −
  • AppDelegate inherits from UIResponder that handles iOS events.
  • Implements the delegate methods of UIApplicationDelegate, which provides key application events like finished launching, about to terminate and so on.
  • UIWindow object to manage and co-ordinate the various views on the iOS device screen. It's like the base view over which all other views are loaded. Generally there is only one window for an application.
  • UIViewController to handle the screen flow.

AppDelegate.m

// Imports the class Appdelegate's interface
import "AppDelegate.h" 

// Imports the viewcontroller to be loaded
#import "ViewController.h" 

// Class definition starts here
@implementation AppDelegate 


// Method to intimate us that the application launched successfully
- (BOOL)application:(UIApplication *)application 
 didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
   self.window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];
   
   // Override point for customization after application launch.
   self.viewController = [[ViewController alloc]
   initWithNibName:@"ViewController" bundle:nil];
   self.window.rootViewController = self.viewController;
   [self.window makeKeyAndVisible];
   return YES;
}

- (void)applicationWillResignActive:(UIApplication *)application
{
   /* Use this method to release shared resources, save user data,
   invalidate timers, and store enough application state information
   to restore your application to its current state in case it is 
   terminated later. If your application supports background 
   execution, this method is called instead of
   applicationWillTerminate: when the user quits.*/
}

- (void)applicationWillEnterForeground:(UIApplication *)application
{
   /* Called as part of the transition from the background to the 
   inactive state. Here you can undo many of the changes made on 
   entering the background.*/
}

- (void)applicationDidBecomeActive:(UIApplication *)application
{
   /* Restart any tasks that were paused (or not yet started) while 
   the application was inactive. If the application was previously in 
   the background, optionally refresh the user interface.*/
}

- (void)applicationWillTerminate:(UIApplication *)application
{
   /* Called when the application is about to terminate. Save data if 
   appropriate. See also applicationDidEnterBackground:. */
}

- (void)applicationWillTerminate:(UIApplication *)application
{
   /* Called when the application is about to terminate. Save data if appropriate.
   See also applicationDidEnterBackground:. */
}

@end
Important items in code −
  • UIApplication delegates are defined here. All the methods defined above are UI application delegates and contains no user defined methods.
  • UIWindow object is allocated to hold the application allocated.
  • UIViewController is allocated as the window's initial view controller.
  • To make the window visible, makeKeyAndVisible method is called.

ViewController.h

#import  

// Interface for class ViewController
@interface ViewController : UIViewController 

@end
Important items in code −
  • The ViewController class inherits the UIViewController, which provides the fundamental view management model for the iOS applications.

ViewController.m

#import "ViewController.h"

// Category, an extension of ViewController class
@interface ViewController ()

@end

@implementation ViewController  

- (void)viewDidLoad
{
   [super viewDidLoad];
   // Do any additional setup after loading the view, typically from a nib.
}

- (void)didReceiveMemoryWarning
{
   [super didReceiveMemoryWarning];
   // Dispose of any resources that can be recreated.
}

@end
Important items in code −
  • Two methods implemented here are defined in the base class UIViewController.
  • Do initial setup in viewDidLoad which is called after the view loads.
  • didReceiveMemoryWarning method is called in case of memory warning.