Merge pull request #19219 from wordpress-mobile/core-data-context-factory

Adopt NSPersistentContainer for handling context objects

Author: crazytonyli

WordPress/Classes/System/WordPress-Bridging-Header.h

@@ -27,6 +27,7 @@
 
 #import "EditCommentViewController.h"
 
+#import "LegacyContextFactory.h"
 #import "LocalCoreDataService.h"
 
 #import "Media.h"

WordPress/Classes/Utility/ContainerContextFactory.swift

@@ -0,0 +1,37 @@
+import ObjectiveC
+
+@objc
+class ContainerContextFactory: NSObject, ManagedObjectContextFactory {
+
+    private let container: NSPersistentContainer
+
+    let mainContext: NSManagedObjectContext
+
+    required init(persistentContainer container: NSPersistentContainer) {
+        self.container = container
+        self.mainContext = container.viewContext
+        self.mainContext.automaticallyMergesChangesFromParent = true
+        self.mainContext.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy
+    }
+
+    func newDerivedContext() -> NSManagedObjectContext {
+        let context = container.newBackgroundContext()
+        context.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy
+        return context
+    }
+
+    func save(_ context: NSManagedObjectContext, andWait wait: Bool, withCompletionBlock completionBlock: (() -> Void)?) {
+        let block: () -> Void = {
+            self.internalSave(context)
+            DispatchQueue.main.async {
+                completionBlock?()
+            }
+        }
+        if wait {
+            context.performAndWait(block)
+        } else {
+            context.perform(block)
+        }
+    }
+
+}

WordPress/Classes/Utility/ContextManager+ErrorHandling.swift

@@ -55,8 +55,40 @@ private extension NSExceptionName {
     static let coreDataSaveDerivedException = NSExceptionName("Unresolved Core Data save error (Derived Context)")
 }
 
-extension ContextManager {
-    @objc(handleSaveError:inContext:)
+extension LegacyContextFactory {
+
+    /// A wrapper of `internalSave(_:)` to expose it as an Objective-C API for `LegacyContextFactory` to call.
+    @objc func internalSaveContext(_ context: NSManagedObjectContext) {
+        internalSave(context)
+    }
+
+}
+
+extension ManagedObjectContextFactory {
+
+    func internalSave(_ context: NSManagedObjectContext) {
+        guard context.hasChanges else {
+            return
+        }
+
+        let inserted = Array(context.insertedObjects)
+        do {
+            try context.obtainPermanentIDs(for: inserted)
+        } catch {
+            DDLogError("Error obtaining permanent object IDs for \(inserted), \(error)")
+        }
+
+        do {
+            try context.save()
+        } catch {
+            handleSaveError(error as NSError, in: context)
+        }
+    }
+
+}
+
+private extension ManagedObjectContextFactory {
+
     func handleSaveError(_ error: NSError, in context: NSManagedObjectContext) {
         let isMainContext = context == mainContext
         let exceptionName: NSExceptionName = isMainContext ? .coreDataSaveMainException : .coreDataSaveDerivedException
@@ -68,9 +100,7 @@ extension ContextManager {
         let exception = NSException(name: exceptionName, reason: reason, userInfo: nil)
         exception.raise()
     }
-}
 
-private extension ContextManager {
     func reasonForError(_ error: NSError) -> String {
         if error.code == NSValidationMultipleErrorsError {
             guard let errors = error.userInfo[NSDetailedErrorsKey] as? [NSError] else {

WordPress/Classes/Utility/ContextManager.h

@@ -1,6 +1,8 @@
 #import <Foundation/Foundation.h>
 #import <CoreData/CoreData.h>
 
+#import "ManagedObjectContextFactory.h"
+
 NS_ASSUME_NONNULL_BEGIN
 
 /**
@@ -59,8 +61,9 @@ FOUNDATION_EXTERN NSString * const ContextManagerModelNameCurrent;
                   Use ContextManagerModelNameCurrent for current version, or
                   "WordPress <version>" for specific version.
  @param storeURL Database location. Use +[ContextManager inMemoryStoreURL] to create an in-memory database.
+ @param contextFactory A type that conforms to `ManagedObjectContextFactory`.
  */
-- (instancetype)initWithModelName:(NSString *)modelName storeURL:(NSURL *)storeURL NS_DESIGNATED_INITIALIZER;
+- (instancetype)initWithModelName:(NSString *)modelName storeURL:(NSURL *)storeURL contextFactory:(Class<ManagedObjectContextFactory> _Nullable)factory NS_DESIGNATED_INITIALIZER;
 
 
 ///--------------------------

WordPress/Classes/Utility/ContextManager.m

@@ -1,4 +1,5 @@
 #import "ContextManager.h"
+#import "LegacyContextFactory.h"
 #import "WordPress-Swift.h"
 @import WordPressShared.WPAnalytics;
 @import Foundation;
@@ -18,13 +19,11 @@ @interface ContextManager ()
 
 @property (nonatomic, strong) NSPersistentStoreDescription *storeDescription;
 @property (nonatomic, strong) NSPersistentContainer *persistentContainer;
-@property (nonatomic, strong) NSPersistentStoreCoordinator *persistentStoreCoordinator;
 @property (nonatomic, strong) NSManagedObjectModel *managedObjectModel;
-@property (nonatomic, strong) NSManagedObjectContext *mainContext;
-@property (nonatomic, strong) NSManagedObjectContext *writerContext;
 @property (nonatomic, assign) BOOL migrationFailed;
 @property (nonatomic, strong) NSString *modelName;
 @property (nonatomic, strong) NSURL *storeURL;
+@property (nonatomic, strong) id<ManagedObjectContextFactory> contextFactory;
 
 @end
 
@@ -43,25 +42,27 @@ - (instancetype)init
         storeURL = [self localDatabasePath];
     }
 
-    return [self initWithModelName:ContextManagerModelNameCurrent storeURL:storeURL];
+    return [self initWithModelName:ContextManagerModelNameCurrent storeURL:storeURL contextFactory:nil];
 }
 
-- (instancetype)initWithModelName:(NSString *)modelName storeURL:(NSURL *)storeURL
+- (instancetype)initWithModelName:(NSString *)modelName storeURL:(NSURL *)storeURL contextFactory:(Class)factory
 {
     self = [super init];
     if (self) {
+        if (factory == nil) {
+            factory = [ContainerContextFactory class];
+        }
+
         NSParameterAssert([modelName isEqualToString:ContextManagerModelNameCurrent] || [modelName hasPrefix:@"WordPress "]);
         NSParameterAssert([storeURL isFileURL]);
+        NSParameterAssert([factory conformsToProtocol:@protocol(ManagedObjectContextFactory)]);
 
         self.modelName = modelName;
         self.storeURL = storeURL;
 
         [NSValueTransformer registerCustomTransformers];
-        // Create `mainContext` and `writerContext` during initialisation to
-        // ensure they are only created once.
-        [self createWriterContext];
-        [self createMainContext];
-        [self startListeningToMainContextNotifications];
+        self.contextFactory = (id<ManagedObjectContextFactory>)[[factory alloc] initWithPersistentContainer:self.persistentContainer];
+        [[[NullBlogPropertySanitizer alloc] initWithContext:self.contextFactory.mainContext] sanitize];
     }
 
     return self;
@@ -84,118 +85,31 @@ + (NSURL *)inMemoryStoreURL
 
 #pragma mark - Contexts
 
-- (NSManagedObjectContext *const)newDerivedContext
-{
-    return [self newChildContextWithConcurrencyType:NSPrivateQueueConcurrencyType];
-}
-
-- (void)createWriterContext
+- (NSManagedObjectContext *)mainContext
 {
-    NSAssert(self.writerContext == nil, @"%s should only be called once", __PRETTY_FUNCTION__);
-
-    NSManagedObjectContext *context = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSPrivateQueueConcurrencyType];
-    context.persistentStoreCoordinator = self.persistentStoreCoordinator;
-    self.writerContext = context;
+    return self.contextFactory.mainContext;
 }
 
-- (void)createMainContext
-{
-    NSAssert(self.mainContext == nil, @"%s should only be called once", __PRETTY_FUNCTION__);
-
-    NSManagedObjectContext *context = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSMainQueueConcurrencyType];
-    context.parentContext = self.writerContext;
-    self.mainContext = context;
-    [[[NullBlogPropertySanitizer alloc] initWithContext:context] sanitize];
-}
-
-- (NSManagedObjectContext *const)newChildContextWithConcurrencyType:(NSManagedObjectContextConcurrencyType)concurrencyType
+- (NSManagedObjectContext *const)newDerivedContext
 {
-    NSManagedObjectContext *childContext = [[NSManagedObjectContext alloc]
-                                            initWithConcurrencyType:concurrencyType];
-    childContext.parentContext = self.mainContext;
-    childContext.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy;
-
-    return childContext;
+    return [self.contextFactory newDerivedContext];
 }
 
-
 #pragma mark - Context Saving and Merging
 
 - (void)saveContextAndWait:(NSManagedObjectContext *)context
 {
-    [self saveContext:context andWait:YES withCompletionBlock:nil];
+    [self.contextFactory saveContext:context andWait:YES withCompletionBlock:nil];
 }
 
 - (void)saveContext:(NSManagedObjectContext *)context
 {
-    [self saveContext:context andWait:NO withCompletionBlock:nil];
+    [self.contextFactory saveContext:context andWait:NO withCompletionBlock:nil];
 }
 
 - (void)saveContext:(NSManagedObjectContext *)context withCompletionBlock:(void (^)(void))completionBlock
 {
-    [self saveContext:context andWait:NO withCompletionBlock:completionBlock];
-}
-
-
-- (void)saveContext:(NSManagedObjectContext *)context andWait:(BOOL)wait withCompletionBlock:(void (^)(void))completionBlock
-{
-    // Save derived contexts a little differently
-    if (context.parentContext == self.mainContext) {
-        [self saveDerivedContext:context andWait:wait withCompletionBlock:completionBlock];
-        return;
-    }
-
-    if (wait) {
-        [context performBlockAndWait:^{
-            [self internalSaveContext:context withCompletionBlock:completionBlock];
-        }];
-    } else {
-        [context performBlock:^{
-            [self internalSaveContext:context withCompletionBlock:completionBlock];
-        }];
-    }
-}
-
-- (void)saveDerivedContext:(NSManagedObjectContext *)context andWait:(BOOL)wait withCompletionBlock:(void (^)(void))completionBlock
-{
-    if (wait) {
-        [context performBlockAndWait:^{
-            [self internalSaveContext:context];
-            [self saveContext:self.mainContext andWait:wait withCompletionBlock:completionBlock];
-        }];
-    } else {
-        [context performBlock:^{
-            [self internalSaveContext:context];
-            [self saveContext:self.mainContext andWait:wait withCompletionBlock:completionBlock];
-        }];
-    }
-}
-
-- (void)internalSaveContext:(NSManagedObjectContext *)context withCompletionBlock:(void (^)(void))completionBlock
-{
-    [self internalSaveContext:context];
-
-    if (completionBlock) {
-        dispatch_async(dispatch_get_main_queue(), completionBlock);
-    }
-}
-
-- (void)mergeChanges:(NSManagedObjectContext *)context fromContextDidSaveNotification:(NSNotification *)notification
-{
-    [context performBlock:^{
-        // Fault-in updated objects before a merge to avoid any internal inconsistency errors later.
-        // Based on old solution referenced here: http://www.mlsite.net/blog/?p=518
-        NSSet* updates = [notification.userInfo objectForKey:NSUpdatedObjectsKey];
-        for (NSManagedObject *object in updates) {
-            NSManagedObject *objectInContext = [context existingObjectWithID:object.objectID error:nil];
-            if ([objectInContext isFault]) {
-                // Force a fault-in of the object's key-values
-                [objectInContext willAccessValueForKey:nil];
-            }
-        }
-        // Continue with the merge
-        [context mergeChangesFromContextDidSaveNotification:notification];
-    }];
+    [self.contextFactory saveContext:context andWait:NO withCompletionBlock:completionBlock];
 }
 
 - (void)performAndSaveUsingBlock:(void (^)(NSManagedObjectContext *context))aBlock
@@ -214,7 +128,7 @@ - (void)performAndSaveUsingBlock:(void (^)(NSManagedObjectContext *context))aBlo
     [context performBlock:^{
         aBlock(context);
 
-        [self saveContext:context andWait:NO withCompletionBlock:completion];
+        [self.contextFactory saveContext:context andWait:NO withCompletionBlock:completion];
     }];
 }
 
@@ -297,46 +211,9 @@ - (NSManagedObjectModel *)managedObjectModel
     return _managedObjectModel;
 }
 
-- (NSPersistentStoreCoordinator *)persistentStoreCoordinator
-{
-    return self.persistentContainer.persistentStoreCoordinator;
-}
-
-
-#pragma mark - Notification Helpers
-
-- (void)startListeningToMainContextNotifications
-{
-    NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
-    [nc addObserver:self selector:@selector(mainContextDidSave:) name:NSManagedObjectContextDidSaveNotification object:self.mainContext];
-}
-
-- (void)mainContextDidSave:(NSNotification *)notification
-{
-    // Defer I/O to a BG Writer Context. Simperium 4ever!
-    //
-    [self.writerContext performBlock:^{
-        [self internalSaveContext:self.writerContext];
-    }];
-}
-
 
 #pragma mark - Private Helpers
 
-- (void)internalSaveContext:(NSManagedObjectContext *)context
-{
-    NSParameterAssert(context);
-    
-    NSError *error;
-    if (![context obtainPermanentIDsForObjects:context.insertedObjects.allObjects error:&error]) {
-        DDLogError(@"Error obtaining permanent object IDs for %@, %@", context.insertedObjects.allObjects, error);
-    }
-    
-    if ([context hasChanges] && ![context save:&error]) {
-        [self handleSaveError:error inContext:context];
-    }
-}
-
 - (void)migrateDataModelsIfNecessary:(SentryStartupEvent *)sentryEvent
 {
     if (![[NSFileManager defaultManager] fileExistsAtPath:[[self storeURL] path]]) {

WordPress/Classes/Utility/LegacyContextFactory.h

@@ -0,0 +1,10 @@
+#import <Foundation/Foundation.h>
+#import "ManagedObjectContextFactory.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface LegacyContextFactory : NSObject <ManagedObjectContextFactory>
+
+@end
+
+NS_ASSUME_NONNULL_END