You need to add some code to the Xcode project that is built when you Build for iPhone.

It's quite a process to get the workflow for this right, but it's worth doing the homework. I published my project once to a folder named 'Unity-iPhone' in my Unity project folder, copied it out to a new, separate location, and then added the following script to my Unity project's Assets/Editor/ folder as PostprocessBuildPlayer (making sure to give executable permissions to the file):

#!/bin/bash
cp -f ./Unity-iPhone/Data/* ~/Documents/Xcode/my-project/Data/.
cp -f ./Unity-iPhone/Libraries/* ~/Documents/Xcode/my-project/Libraries/.

What this does is copy all the bits that actually change in an Xcode build and leaves the rest of your project intact. I have lost one too many days trusting Unity's own 'Append' feature.

You can then develop happily in Xcode in the ~/Documents/Xcode/my-project project. To get the plugin going, first rename ProjectAppDelegate.m to http://ProjectAppDelegate.mm. This tells the compiler to process C and C++ code in the file (or something). Then, above the @implementation line near the top, add:

static ProjectAppDelegate delegateObj;

Then, in your applicationDidFinishLaunching method, you set this value:

- (void)applicationDidFinishLaunching:(UIApplication *)application {
    delegateObj = self;
    ...
}

This allows your plugin's C code to talk to your application's Objective-C code.

Then add the following code at the bottom of the App Delegate .mm file. I have included a sample of how to pass structured data back and forth (I struggled with this, should save you some time).

NSString* CreateNSString (const char* string) {
    return [NSString stringWithUTF8String: string ? string : ""];
}

char* MakeStringCopy (const char* string) {
    if (string == NULL) return NULL;
    char* res = (char*)malloc(strlen(string) + 1);
    strcpy(res, string);
    return res;
}

struct MyStruct {
    char* stringValue;
    int intValue;
};

extern "C" {    
    void _PassStructFromObjCToUnity ( struct MyStruct *myStruct ) {
    	NSLog(@"_PassStructFromObjCToUnity");

    	myStruct->stringValue = MakeStringCopy([delegateObj.someStringProperty UTF8String]);
    	myStruct->intValue = [delegateObj.someNSNumberProperty intValue];

    	printf("-> myStruct->stringValue %s\n", myStruct->stringValue);
    	printf("-> myStruct->intValue %s\n", myStruct->intValue);
    	NSLog(@"-> complete.");
    }

    void _HaveObjCDoSomething () {
    	NSLog(@"_HaveObjCDoSomething");
    	[delegateObject doSomething];
    	NSLog(@"-> complete.");
    }	
}

Finally, in Unity, in a C# class in Assets/Plugins/, you'd have something like:

using UnityEngine;
using System.Runtime.InteropServices;

public struct MyStruct
{
    public string stringValue;
    public int intValue;
}

public class OBJCPlugin 
{
    [DllImport ("__Internal")]
    private static extern void _PassStructFromObjCToUnity ( ref MyStruct myStruct );

    public static MyStruct PassStructFromObjCToUnity ()
    {
    	Debug.Log("OBJCPlugin.PassStructFromObjCToUnity");
    	MyStruct data = new MyStruct();
    	if ( Application.platform == RuntimePlatform.IPhonePlayer )
    	{
    		_PassStructFromObjCToUnity( ref data );
    	}
    	return data;
    }	

    [DllImport ("__Internal")]
    private static extern void _HaveObjCDoSomething ();

    public static void HaveObjCDoSomething ()
    {
    	Debug.Log("OBJCPlugin.HaveObjCDoSomething");
    	if ( Application.platform == RuntimePlatform.IPhonePlayer )
    	{
    		_HaveObjCDoSomething();
    	}
    }
}

Of course, there is more to it than just what you have here, but this is a good kickstart. Have fun :)

I have tried using this PostprocessBuildPlayer script but I get a runtime error when running with the copied libs. "Failed to load AOT module 'mscorelib' while running in aot-only mode."

thanks for the info. that's very helpful!

the main point of my confusion was that i was under the impression that 'plugins' for iphone worked the same way as if you were building for pc/mac: a precompiled bundle that unity loaded and accessed through interop. i see now that on iphone, it is just the ability to access objC code that has been added to the xcode project. very misleading nomenclature using the term 'plugin' for both.