What the heck is Memento?

Quick definition:

“Without violating encapsulation, capture and externalize an object’s internal state so that the object can be restored to this state later”, Design Patterns, by the “Gang of Four” (Addison-Wesley, 1994)

Let’s say we have an object or thousands of objects and we want to store them when the user saves the state of the work/game/application or in dozens of other cases. A memento is an object that keeps the information about the state of the other object. Thus, the memento encapsulates information that can be used to recreate the original object.

To make the pattern work we need objects that fulfill roles of:

• originator – creates a memento with all information that is relevant for us and will be useful later to recreate the object,
• memento – stores the information about the state of the originator object
• caretaker – stores the memento somewhere in the memory.

Everything’s easy. The caretaker asks originator to create a memento. Originator creates the memento. However, the originator does not know how to save it. This is done by the caretaker, which takes the memento and stores it in the file system (for instance as a NSData or a plist). In case of loading the memento from the file system steps are analogical.

Cocoa Touch uses the Memento pattern in archiving, property list serialization and Core Data.

Aha, and what is this Proxy all about?

Quick definition:

“Provides a surrogate or placeholder for another object to control access to it.“, Design Patterns, by the “Gang of Four” (Addison-Wesley, 1994)

The main idea of the Proxy pattern is very easy. Let’s say we have an image we would like to present in our UIImageView. However, the image is located on the external server and we need to fetch it. So, in order to raise the user’s experience we are presenting the placeholder image and when the download is finished we update the photo. This is all about Proxy pattern.

We can apply Proxy pattern to an iOS app to lazy-load the data that is expensive in terms of memory usage. A virtual proxy object gives some sort of initial information of the object that will be loaded when the user requests it.
References:
Pro Objective-C Design Patterns for iOS, Carlo Chung

Model-view-controller concept. The solid line represents a direct association, the dashed an indirect association (via an observer for example). Source: Wikipedia.

In object-oriented programming, design patterns show a general view of how classes and objects interact, describe their relationships. They are like a sign on a crossroads, pointing to the possible solution for a given problem.

With design patterns you can develop fast and effectively. However, using a particular design pattern is not a mandatory, the only right way of achieving desired functionality. A developer has to keep in mind all the limitation and drawbacks of using the design pattern that seems to fit well as a good solution for a given task.

Quality, not quantity.

Someone has recently asked me if a code that uses more design patterns is better then the code that utilizes only a few of them. Of course, it is not about the quantity. A developer may use only one design pattern (or doesn’t use any at all) and the app may work perfectly, the code can be clean and professional. It all depends on the particular application or a feature the developer is dealing with. Quality, this is what counts.

Classification

I will not reinvent the wheel here, there is a nice presentation of the classification of the design patterns in the article about the design patterns on wikipedia.

So how it looks in iOS development?

Here I present some examples of classes and approaches that fulfill the rules of several design patterns. Firstly, I present the Model View Controller (MVC) pattern that you must have encountered during the development of a view (or window) based application.

Model-View Controller pattern

In MVC, every controller owns a view and a model (with data presented by the view). In fact, the MVC pattern consists of a set of more primitive patterns. I will introduce them here:

• Composite – Views form a hierarchy. Each view has a strictly specified position in the view hierarchy. Each view can be drawn on screen or respond to touch events. What is more, every view can be a parent node for another set of views. This pattern is very common. When we add UIButton, UITextField, UITableView or any other UIView to the parent UIView of UIViewController we utilize this patterns.

• Command – The mighty target-action approach. Views can defer and forward execution to other objects (in most cases they forward it to our UIViewController subclass). The execution is forwarded to other objects when certain events occur (for instance user taps a button – UIControlEventTouchUpInside).

• Mediator – Our view controller mediates between our presentation layer (the views) and model layer. The interaction is bi-directional. So, if the model changes the view objects are informed about this change not directly but via the Mediator (our UIViewController).

• Strategy – The fact that view objects interact not directly with the Model but using the Mediator pattern with controller object gives as a good starting point to use a Strategy pattern. The controller decides which “strategy” will be the best for dealing with the particular problem (f.e. which algorithm to use with data acquired from the user by view objects).

• Observer – This pattern is very common throughout whole Cocoa. If a model gets updated it may inform all objects that registered as the observers about the change that occurred. This can also be done in the opposite direction, when model should be updated, because user interacted with the model through the view objects. Now you probably think about Protocols, Key-Value Observing and Notification Center. That’s right, these are all perfectly working examples of the Observer design pattern.

References:
Pro Objective-C Design Patterns for iOS, Carlo Chung

The MC68HC908AB32 is a member of the low-cost, high-performance M68HC08 Family of 8-bit microcontroller units (MCUs) designed by Motorola with embedded EEPROM for user data storage. This article presents the source code for Knight 1 Robot which I developed as a part of Microprocessor course at my uni. Special thanks to my friend Łukasz Siwko who helped in the construction of this electronic monster.

The code is very simple. There was much more work in setting up the electronic elements then in writing the C program. The code handles the reception of the signals from the ultrasonic sensor and the management of two engines (A and B) of the robot that is based on MC68HC908AB32 microcontroller unit. If an obstacle is detected the engines turn the robot right by stoping the right engine (A stops, B full forward).

Two words about pins

PTB_PTB1 to PTB_PTB6 are Port B data register pins from 1 to 6 connected to engine motion control circuit. Pins 1 and 4 enable engines while pins 2,3,5,6 control the movement (10 – forward, 01 – reverse).

PTB_PTB0 (Port B data register pin 0) contains information (logical 0 or 1) from connected ultrasonic sensor receiver circuit about obstacle in view. Sensor sends logical 1 on obstacle detection (0 – no obstacle in view). Output pin of this sensor is connected to Port B data register pin 0.

 
#include <time.h>
#include <hidef.h> /* for EnableInterrupts macro */
#include "derivative.h" /* include peripheral declarations */
#define DELAY 10000
void moveForward(void);
void turnRight(void);
int checkSensors(void);
void main(void) {
    EnableInterrupts; /* enable interrupts */
    for(;;) {
        __RESET_WATCHDOG(); /* feeds the dog */
        if(checkSensors()) {
            turnRight();
        }
        else {
            moveForward();
        }
    } /* loop forever */
    /* please make sure that you never leave main */
}
void turnRight(void) { /* Turns the robot right. */
    int i=0;
    /* Engine A stop */
    PTB_PTB1 = 1; // Enable
    PTB_PTB2 = 1; // Input 1
    PTB_PTB3 = 0; // Input 2
    /* Engine B full forward */
    PTB_PTB4 = 1; // Enable
    PTB_PTB5 = 0; // Input 1
    PTB_PTB6 = 1; // Input 2
    /* sleep(1) */
    /* Sleeping unsupported, using a "for" loop to cause a delay */
    for(i=0;i<DELAY;i++){}
}
void moveForward(void) {
    /* Engine A full forward */
    PTB_PTB1 = 1; // Enable
    PTB_PTB2 = 1; // Input 1
    PTB_PTB3 = 0; // Input 2
    /* Engine B full forward */
    PTB_PTB4 = 1; // Enable
    PTB_PTB5 = 1; // Input 1
    PTB_PTB6 = 0; // Input 2
    /* PTB_PTB1 - 6 are Port B data register pins from 1 to 6 connected
to engine motion control circuit. Pins 1 and 4 enable engines while pins 2,3,5,6
control the movement (10 - forward, 01 - reverse). */
}
int checkSensors(void) { /* Checks whether the obstacle was detected.
Returns 1 on successful detection.*/
    if (PTB_PTB0 == 1) return 1;
    else return 0;
    /* PTB_PTB0 (Port B data register pin 0) contains information (logical 0 or 1)
from connected ultrasonic sensor receiver circuit about obstacle in view. Sensor sends
logical 1 on obstacle detection (0 - no obstacle in view). Output pin of this sensor is
connected to Port B data register pin 0. */
}

This code is available at my GitHub under GPL license. Feel free to download.

UIImage Sprite Additions

I wrote an useful UIImage category for handling sprite sheets. The add-on smoothes the way of extracting images from a sprite sheet (or texture atlas).

This can be useful in UIImageView animations where animationImages array has to be filled with a set of images representing frames. UIImage-Sprite category makes this process trivial by introducing two methods:

-(NSArray *)spritesWithSpriteSheetImage:(UIImage *)image spriteSize:(CGSize)size; -(NSArray *)spritesWithSpriteSheetImage:(UIImage *)image inRange:(NSRange)range spriteSize:(CGSize)size; 

The first method returns an array with UIImages. Original sprite sheet (image) is sliced into smaller chunks, each of the specified size.

Second method is very similar – extends the first one with option of specifying the range of the chunks we want to get.

I wrote this add-on to facilitate the setup of short animations using UIImageView. For more complex animations I recommend using OpenGLES.

I also wrote the SpriteAnimationDemo project that presents the usage of the UIImage+Sprite methods. The example shows how to create an animated UIImageView. This cool explosion sprite sheet which I included in the demo can be found at http://gushh.net/blog/free-game-sprites-explosion-3/. I added some numbers to this image to make testing and debugging easier.

The code is distributed under the terms and conditions of the MIT license and can be found at my github: https://github.com/r3econ/UIImage-Sprite-Additions

Note that for performance reasons you should not fire these methods every time you want to get the array of animation frames. You should rather fire it once and store the output array somewhere. This is because the Core Graphics image manipulation operations (especially on large images) are not so fast and your application may slow down.

Noughts and Crosses iPhone App

Everybody knows what Tic Tac Toe or Noughts and Crosses game is. Everyone has played it. It is simple, trivial or someone may even say stupid. Whateverm I made a full, complete working iPhone game – Noughts and Crosses. For those who still don’t know what I am talking about please take a look at  a brief information about the rules and origins of the game at wikipedia.

Although the game, its rules and implementation are rather trivial, it took me several evenings to code it. It was made just for fun to show my coding etiquette and my development habits. There is also another reason – I decided to create something that may help those that start messing with iOS development. The project covers such topics as:

• UIView animations
• Protocols and delegates
• Custom UI components
• Playing with UIActionsheet, UIAlertView
• Creation of UI controls from code
• CALayers (adding shadows, rounded corners)

To present some short notifications about game progress, I needed an equivalent of Android’s Toast component. That was a reason for developing a RSToast class – a UI component that presents a short message and disappears after a short time without the need for tapping on it. Current version of RSToast is very simple. However, I will extend it to support icons and add some helper methods for customizing its appearance.

The source code is publicly available, released under MIT license. Xcode project can be downloaded from github. Feel free to download and criticize!

[self performSelectorInBackground:@selector(customMethod:) withObject:nil];

[NSThread detachNewThreadSelector:@selector(customMethod:) toTarget:self withObject:nil];

After running our app we may see something strange in logs:

App[7254:7d03] *** __NSAutoreleaseNoPool(): Object 0x27b7a0 of class NSCFString autoreleased with no pool in place - just leaking

This log message indicates that we are leaking an object. To solve this and get rid of the memory leak, we have to set up our own autorelease pool that will clean the memory for us.

-(void)customMethod:(id)customObject {

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
//
// Your code here
//
[pool release]; // or [pool drain]; pool = nil;

}

R2 2 0 15K TC=0.001 0.000005

R1 1 2 15k

Vin 0 1 10

.DC TEMP -50 100 2

.PROBE

.END

In probe: (V(1)- V(2))/ I(R1) and  V(2)/ I(R2)

After running the simulation we get some interesting results, R1 resistance is fixed while R2 resistance increases as the temperature rises:

Here is how I managed to symbolicate the crash:

reecon$/Xcode4.0/Platforms/iPhoneOS.platform/Developer/Library/PrivateFrameworks/DTDeviceKit.framework/Versions/A/Resources/symbolicatecrash your_crash_log.crash

Above-mentioned command produces the very same output that Xcode does when it’s symbolicating logs.

What is interesting, after installing Xcode 4, iPhone devices that I use for testing does not load their crash logs when they are connected to my Mac. To force it to do so, I have to synchronise the iPhones in iTunes and reboot the device every time I want to get the logs. That is strange. I hope they will fix it soon.

At first we must configure a trunk on a switch:

Switch(config)# interface fastethernet 0/1
Switch(config-if)# switchport mode trunk
Switch(config-if)# switchport trunk encapsulation dot1q

You can also specify trunk native vlan and vlans allowed on a trunk. Remember that 802.1Q encapsulation type is the IEEE standard, is Cisco proprietary.

Switch(config-if)#switchport trunk native vlan 99
Switch(config-if)#switchport trunk allowed vlan add 10

Now we have to configure subinterfaces on a router to make trunk work:

Router(config-if)#no ip address
 Router(config-if)#no shutdown
 Router(config-if)#interface fa 0/1.10
 Router(config-subif)#encapsulation dot1q 10
 Router(config-subif)#ip address 192.168.10.254 255.255.255.0
 Router(config-subif)#interface fa 0/1.20
 Router(config-subif)#encapsulation dot1q 20
 Router(config-subif)#ip address 192.168.20.254 255.255.255.0

Hosts A and B should now configure their default-gateways to 192.168.10.254 and 192.168.20.254 and be able to ping each other. That’s all.

This article presents a quick How-To that shows how to use local notifications. For more information check the UILocalNotification Class Reference. Remember that UILocalNotification is available in iOS 4.0 and later.

Introduction

Implementing local notifications is very easy – all we have to do is to inform the operating system that we want to schedule a new notification. OS will show scheduled notification at the specified time. With UILocalNotification we are able to play alerts, sounds, and badging application icon. In this example we will use a instance of UIDatePicker that will allow user to specify the time for the notification to occur and a UIButton.

When user clicks the button, action setReminderUsingDateFromDatePicker will schedule a notification with date picked from UIDatePicker. Setting the notification is done in scheduleNotificationForDate method. Let’s jump to the code.

Implementation

This is a UIButton’s action that schedules the notification. UIDatePicker must be set up, and linked with code (f.e in Interface Builder) to make this work. Action setReminderUsingDateFromDatePicker is attached to UIButton object and simply schedules notification for a date that was picked using UIDatePicker:

-(IBAction)setReminderUsingDateFromDatePicker: (id)sender {

/* datePicker is a UIDatePicker object, synthesized property, linked using IB */
 [self scheduleNotificationForDate: datePicker.date];

UIAlertView  *alert = [[UIAlertView alloc] initWithTitle:@""
             message:@"Alarm has  been set"
             delegate:self cancelButtonTitle:@"OK" 
             otherButtonTitles:nil];

[alert show];
[alert release];
}

Here is a main part of implementing notification:

-(void) scheduleNotificationForDate: (NSDate*)date {

/* Here we cancel all previously scheduled notifications */
 [[UIApplication sharedApplication] cancelAllLocalNotifications];

UILocalNotification *localNotification = [[UILocalNotification alloc] init];

localNotification.fireDate = date;
NSLog(@"Notification will be shown on: %@",localNotification.fireDate);

localNotification.timeZone = [NSTimeZone defaultTimeZone];
localNotification.alertBody = [NSString stringWithFormat:
                              @"Your notification message"];
localNotification.alertAction = NSLocalizedString(@"View details", nil);

/* Here we set notification sound and badge on the app's icon "-1" 
means that number indicator on the badge will be decreased by one 
- so there will be no badge on the icon */

localNotification.soundName = UILocalNotificationDefaultSoundName;
localNotification.applicationIconBadgeNumber = -1;

[[UIApplication sharedApplication] scheduleLocalNotification:localNotification];
}

Here is an example of setting the notification for a fixed date.

-(IBAction)setReminder {

// Setting all the information about our date
int hour = 4;
int minutes = 15;
int day = 21;
int month = 12;
int year = 2012;

NSCalendar *calendar = [[NSCalendar alloc] initWithCalendarIdentifier:NSGregorianCalendar];
NSDateComponents *components = [[NSDateComponents alloc] init];

[components setDay:day];
[components setMonth:month];
[components setYear:year];
[components setMinute:minutes];
[components setHour:hour];

NSDate *myNewDate = [calendar dateFromComponents:components];
[components release];
[calendar release];

[self scheduleNotificationForDate:myNewDate];

UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@""
               message:@"Alarm has been set"
               delegate:self cancelButtonTitle:@"OK"
               otherButtonTitles:nil];
[alert show];
[alert release];
}

That’s all.