Question

I’m working on an exiting iOS app (called Mazin in the App store, if anyone is interested) and I’m trying to rework the code to avoid using the Application Delegate or a singleton for sharing information/methods. In particular I have the following to share across certain views and controllers:

• CoreData objects like NSManagedObjectConttext and related custom methods for interacting with the data
• State properties used in several places like currentMazeType, gameMode, and soundIsMuted along with a few widely used utility methods particular to the game
• Views and methods used to display information used commonly throughout the app (e.g., an ActivityIndicator and methods to show/hide it on a given view)

In general, several views and ViewControllers need access to various subsets of this information and I need a mechanism to share the information and methods “globally” across these objects. Some of this sharing is for convenience (e.g., every time I want to display a basic activity indicator, I just call a common “startActivityIndicator” method) but some are required (e.g., changing gameMode changes it “globally” and several views/controllers need to access the common mode info).

What sort of patterns would work best for this requirement? I have my own solution in mind, and I’ll post it below for your consideration/comments.

Thanks!

Answer 1

Solution I am considering:

I plan to create a few “utility” classes (e.g. GameDataUtil, AppStateUtil, GadgetsUtil) that each encapsulate a proper subset of the “global” information and/or methods. Each View or ViewController that needs to access the common info/methods in a utility will have an appropriate property of that given type (e.g., a view that can make a sound needs access to the AppStateUtil so it can determine if sounds are currently muted).

The ApplicationDelegate will be the only class that generates single instances of the “utility” classes and will pass those instances to the appropriate objects that get loaded from its Nib (in applicationDidFinishLaunching). Those views/controllers will have to pass all necessary information to any of their members that they may load programmatically (which could get hairy–class A may need a GagetsUtil in order to pass it to an instance of class B even though class A never uses the utility directly).

This is sort of like injecting dependencies from the application delegate down (since I don’t have the utility of an Dependency Injection Container).

Now, I have thought about creating an uber-utility (e.g., ConfigUtil) that would hold one property for each of the other utilities. The AppDelegate would create a single instance of the uber-utility (setting it up with instances of the other utilities it creates). The AppDelegate would pass the uber-utility instance to anyone who needs access to any of the basic utilities. Each basic utility would still encapsulate a sub-set of the common data/methods, but by putting one of each into an uber-utility and passing it around, I don’t have to keep up with which utility is needed by which class (not only for its own use but also to pass to any of its member objects).