I rearranged the files in my program folder, grouping them into appropriate subfolders. I made sure they all show up in the compiled sources list, including the 'xcdatamodeld' file.
However, creating a managed object model is not working with the following code:
if (mom_ != nil) {
return mom_;
}
self.mom = [NSManagedObjectModel mergedModelFromBundles:nil];
return mom_;
I examined [NSBundle mainBundle], and specifically
[[NSBundle mainBundle] pathForResource:#"Words" ofType:#"xcdatamodeld"]
and
[[NSBundle mainBundle] pathForResource:nil ofType:#"xcdatamodeld"]
They both return nil. I can see that other resources are there when I check for them by name and type.
There is a folder called "Words.momd" in the app bundle file.
What might have happened and how can it be fixed?
Try using:
NSURL *modelURL = [[NSBundle mainBundle] URLForResource:#"Words" withExtension:#"momd"];
You want to load the compiled data model, vs. the xcdatamodeld file:
A data model is a deployment resource. In addition to details of the entities and properties in the model, a model you create in Xcode contains information about the diagram—its layout, colors of elements, and so on. This latter information is not needed at runtime. 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.
(source)
You can use MagicalRecords framework for it:
https://github.com/magicalpanda/MagicalRecord
and setup your db in one line of code:
[MagicalRecord setupCoreDataStackWithAutoMigratingSqliteStoreNamed:#"Words"];
Related
Is it possible to serve two xcdatamodeld core data in the same project and load each according to a conditional?
I have BTPModel.xcdatamodeld and FTModel.xcdatamodeld
According to the comments this line below does this:
NSManagedObjectModel model = [NSManagedObjectModel mergedModelFromBundles:nil];
// looks up all models in the specified bundles and merges them; if
nil is specified as argument, uses the main bundle
Can I do something like this? (pseudo code)
if (config == #"FT") {
model = [NSManagedObjectModel load:#"FTModel.xcdatamodeld"];
} else {
model = [NSManagedObjectModel load:#"BPTModel.xcdatamodeld"];
}
UPDATE:
I have now tried this
NSURL *url = [[NSBundle mainBundle] URLForResource:#"F11iModel" withExtension:#"xcdatamodeld"];
Without any luck. url remains null.
UPDATE
Extension is momd. Now it works!
NSURL *url = [[NSBundle mainBundle] URLForResource:#"F11iModel" withExtension:#"momd"];
Of course you can. Just a few things to pay attention to:
The loading of a specific model is not done with some load method, but with initWithContentsOfURL. You get the URL with the main bundle's URLForResource. You can pass different resource names to this according to the configuration information.
I would recommend that you also use different persistent stores to make sure there is no attempt to open a the store with the wrong model (which will crash your app).
If I include a folder in my bundle (a real folder, the blue ones, not the yellow groups), how can I get the path for that folder from my bundle? The method I would usually use is...
[[NSBundle mainBundle] pathForResource:fileName ofType:______];
...but what "type" is a directory? Is there a "type" to use, or is there another method for accessing the paths of directories within the bundle?
Or am I going about this all wrong, and there's some other way for including folders of accessible documents in the bundle?
Directories can have extensions too. If yours doesn't have one, just pass #"" for the type parameter, -[NSBundle pathForResource:ofType:] works for directories too, not only files. At the end, a directory is also a resource :)
As per a suggestion in the comments, it turns out you can use an empty string to refer to folders. So a folder called "myFolder" would be accessible using...
[[NSBundle mainBundle] pathForResource:#"myFolder" ofType:#""];
Hope this helps anyone else who wasn't expecting it to be so easy...
As you're adding a folder by your own, you know the name of the folder, so you can get the path like this:
NSString *myDirectoryName = #"myDirectory";
NSString *absolutePathToMyDirectory = [[NSBundle mainBundle].resourcePath stringByAppendingPathComponent:myDirectoryName];
You'll have to test if this path exist with NSFileManager.
Otherwise you can still use the method you're using, the type can be nil, so you can call it like this
NSString *absolutePathToMyDirectory = [[NSBundle mainBundle] pathForResource:myDirectoryName ofType:nil];
and then testing if the result is nil or not.
if(absolutePathToMyDirectory) {
// do stuff related to this path
}
I have images.xcassets listed ounder copy bundle resources, and I did try to just state the file name by itself: MSB_big_icon , before trying to add the path within images.xcassets.
Can anybody tell me what I'm doing wrong?
NSString *path = [[NSBundle mainBundle]pathForResource:#"/Raymio_android_images/MSB_big_icon.imageset/MSB_big_icon" ofType:#"png"];
NSLog(#"path: %#", path);
MSBIcon *tilecon = [MSBIcon iconWithUIImage:[UIImage imageWithContentsOfFile:path] error:&error];
David Ansermot is right that xcassets is a much better approach and strongly preferred. If you can't use that (running on older versions of iOS for instance), still put everything in one directory and use imageNamed:. This has significant caching benefits over hand-loading the file.
An asset catalog (xcassets) is a (relatively) new, unified way of managing image resources. The images are no longer accessible as separate files on the disk. Instead, imageNamed: consults the asset catalog and fetches the correct asset.
Prior to asset catalogs (and still, for non-images), assets were stored in localized directories. All of your unlocalized assets would be put into a directory called Resources (no matter where those files might appear to be in your source tree, and no matter how those files might be arranged in your Xcode folders). Localized files would be stored in directories like English.lproj or French.lproj. When you make NSBundle calls to load MyImage, it looks at each localized directory in the order the user has configured, and if it cannot find it in any of those directories, it looks in Resources.
Now it is possible to store full directories as "a resource" by marking them as directory references in Xcode. In that case, the whole directory would be copied into Resources or the appropriate localized directory. In order to find files inside such a directory you can use the ...inDirectory: version of the NSBundle methods.
So most of the time, you want to just use imageNamed:, which is going to fetch things out of the asset catalog if available, and then search localized directories, and then look in Resources. If you need to find a non-image, or if for some reason you want the real path to the file, you can compute it like this:
NSString *path = [[NSBundle mainBundle] pathForResource:#"MSB_big_icon" ofType:#"png"];
And if that resource were in a directory tree (because it was a directory reference in Xcode), you can access it like this:
NSString *path = [[NSBundle mainBundle] pathForResource:#"MSB_big_icon"
ofType:#"png"
inDirectory:#"Raymio_android_images/MSB_big_icon.imageset"];
Here's a code exemple from one of my apps :
NSString *appKey = #"Applications__GENERIC";
NSString *path = [[NSBundle mainBundle] pathForResource:appKey ofType:#"plist"];
appData = [NSDictionary dictionaryWithContentsOfFile:path];
The "Applications__GENERIC.plist" is stored like this :
Other solutions :
Use the images.xcassets.
Then in your code to load an image, use the code :
UIImage *image = [UIImage imageNamed:#"MyImageWithoutExtension"];
Don't put any path or extension, only the image's name
Try using this:
NSString *path = [[NSBundle mainBundle] pathForResource:#"MSB_big_icon" ofType:#"png" inDirectory:#"Raymio_android_images/MSB_big_icon.imageset"];
What you can also do to debug is to print out
[[NSBundle mainBundle] bundleURL]
Then navigate to that folder and see if the folder structure corresponds to the path you use.
I just struggled with this today, hope it works out for you too.
enter code hereI am working on an import tool, following the pattern objc.io did at https://github.com/objcio/issue-4-importing-and-fetching .
At an early point in the program, where I am creating an instance of NSManagedObjectModel from a url, it is returning nil. When I run the program, the error I get later is "Cannot create an NSPersistentStoreCoordinator with a nil model".
Attached is a screenshot at a breakpoint after I create the model. I've looked around here, and have verified that:
HistologyDataImporter.xcdatamodeld belongs to HistologyDataImporter (target membership)
The NSString I'm using the build the path matches the name of the model file ("HistologyDataImporter")
I have also tried passing "mom" as the extension to URLByAppendingPathComponent, but the model is still nil when run.
Why is [[NSManagedObjectModel alloc] initWithContentsOfURL:modelURL] still returning nil?
Because you're using the wrong location. What you have is:
NSString *path = #"HistologyDataImporter";
NSURL *modelURL = [NSURL fileURLWithPath:path isDirectory:NO];
moelURL = [modelURL URLByAppendingPathComponent:#"momd"];
If you call fileURLWithPath: with a relative path like this, it's assumed to be relative to the current working directory. Your code does not set the working directory, but the value for modelURL suggests it's somewhere in Xcode's derived data folder. That's not surprising when running the app from Xcode, but the model file is not in that directory.
You need to figure out where HistologyDataImporter.momd is located and make sure that modelURL actually points to that location. If you put the model file on your desktop, you could use the same desktopURL that you have in main() and add the model filename to that.
I'm trying to migrate a specific part of one of my apps into a framework so that I can use it in my app itself and in one of those fancy new iOS 8 widgets. This part is the one that handles all my data in Core Data. It's pretty straight forward to move everything over and to access it. I'm just having trouble accessing my momd file in there.
When creating the NSManagedObjectModel I still try to load the momd as illustrated in Apple's code templates:
NSURL *modelURL = [[NSBundle mainBundle] URLForResource:#"MyApp" withExtension:#"momd"];
__managedObjectModel = [[NSManagedObjectModel alloc] initWithContentsOfURL:modelURL];
Unfortunately, modelURL stays nil and thus MyApp crashes when accessing the Core Data stack with this error:
2014-08-01 22:39:56.885 MyApp[81375:7417914] Cannot create an NSPersistentStoreCoordinator with a nil model
2014-08-01 22:39:56.903 MyApp[81375:7417914] *** Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: 'Cannot create an NSPersistentStoreCoordinator with a nil model'
So, what's the right way to do this when working inside a framework with Core Data?
I'm a bit late for flohei's issue, but hopefully this helps anybody else who wanders by. It is possible to get this to work without having to perform script-fu to copy resources around!
By default Apple's Core Data template gives you something like this:
lazy var managedObjectModel: NSManagedObjectModel = {
let modelURL = NSBundle.mainBundle().URLForResource("MyCoreDataModel", withExtension: "momd")!
return NSManagedObjectModel(contentsOfURL: modelURL)!
}()
That would load your Core Data resources out of the main bundle. The key thing here is: if the Core Data model is loaded in a framework, the .momd file is in that framework's bundle. So instead we just do this:
lazy var managedObjectModel: NSManagedObjectModel = {
let frameworkBundleIdentifier = "com.myorg.myframework"
let customKitBundle = NSBundle(identifier: frameworkBundleIdentifier)!
let modelURL = customKitBundle.URLForResource("MyCoreDataModel", withExtension: "momd")!
return NSManagedObjectModel(contentsOfURL: modelURL)!
}()
That should get you up and running.
Credit: https://www.andrewcbancroft.com/2015/08/25/sharing-a-core-data-model-with-a-swift-framework/
You need to drag the xcdatamodeld file and drop it in the Build Phases | Compile Sources for the targets that use the framework. Then when the target runs its [NSBundle mainBundle] will contain the model (momd file).
#Ric Santos was almost there. I think you just need to make it an "mom" extension rather than "momd", then it will run.
lazy var managedObjectModel: NSManagedObjectModel = {
let modelURL = NSBundle(forClass: self.dynamicType.self).URLForResource(self.dataModelName, withExtension: "mom")!
return NSManagedObjectModel(contentsOfURL: modelURL)!
}()
I may be a little late with answering this, but here's what solved my issue:
With my framework I'm delivering also a bundle with resources like images and other stuff. Putting xcdatamodeld file there didn't give anything as this file being built with the project and as a result you get a momd folder in your app bundle (which actually is missing in our case)..
I have created another target, not framework, but app, built it and copied the momd from its app bundle to my separate bundle in the project (the one that goes with framework).
After doing this you just need to change your resource url from main bundle to the new one:
// ...
NSString *bundlePath = [[NSBundle mainBundle] pathForResource:#"separate_bundle" ofType:#"bundle"];
NSURL *modelURL = [[NSBundle bundleWithPath:bundlePath] URLForResource:#"your_model" withExtension:#"momd"];
// ...
Worked fine for me. The only thing I'm aware of is App Store Review which I didn't get to yet.
So if you've found a better solution, please share.
EDIT
Found better solution. You can build the model yourself. From Core Data Programming Guide:
A data model is a deployment resource. In addition to details of the
entities and properties in the model, a model you create in Xcode
contains information about the diagram—its layout, colors of elements,
and so on. This latter information is not needed at runtime. 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.
By "/Developer/usr/bin/" they mean "/Applications/Xcode.app/Developer/usr/bin/"
You can add a script in you target scheme and compile this automatically before each build (or after, don't think it matters). This is in case if you change the model during development.
Something like this:
mkdir -p "${BUILT_PRODUCTS_DIR}/your_model_name.momd"
momc "${SRCROOT}/your_model_path/your_model_name.xcdatamodeld" "${BUILT_PRODUCTS_DIR}/${PRODUCT_NAME}.framework/your_bundle_name.bundle/your_model_name.momd"
The model resource is no longer accessible via the mainBundle, you need to use bundleForClass: like so:
NSURL *modelURL = [[NSBundle bundleForClass:[self class]] URLForResource:#"MyApp" withExtension:#"momd"];
_managedObjectModel = [[NSManagedObjectModel alloc] initWithContentsOfURL:modelURL];
I assume you only require the data model.
If so, I find the following is consistently the most successful method for copying across a data model file from one project to another...
Delete any current copies of .xcdatamodeld file that reside in the target project.
Close Xcode.
Using Finder (or cmd line);
Select your Xcode project folder that contains the original .xcdatamodeld file.
Make a copy of the original .xcdatamodeld file.
Move the copy of the original .xcdatamodeld file to your target project.
Then...
Open Xcode.
Using the Menu command "Add Files to >your project<", find and add the copy of the original .xcdatamodeld file to your project.
Rename the original .xcdatamodeld file (if necessary) using Project Navigator.
"Build & Run" your target project.
Does this help?
If you try to have core data in your framework do like this.
in YourFramework
- add new file / core data / Data model ...
- create all object ....
When creating new project that will use YourFramework be sure that core data is on
This will create all boiler plate inside AppDelegate.
in Test project
- add Framework
- add Framework as embedded framework
- DELETE .xcdatamodeld file
- in AppDelegate :
change - (NSManagedObjectModel *)managedObjectModel method into :
NSBundle * testBundle = [NSBundle bundleWithIdentifier:#"YourFramework bundle id "];
NSURL *modelURL = [testBundle URLForResource:#"Model" withExtension:#"momd"];
where YourFramework bundle id is Bundle Identifier of YourFramework (in General / Bundle Identifier)
and Model is name of your .xcdatamodeld file in YourFramework
This works.
Hope it helps.