This is is a follow-up from my previous PR (#65). It makes gomobile aware of GOOS=ios and adds support for specifying specific Apple platforms, instead of overloading the "ios" platform.

Supported platforms: ios, iossimulator, macos, and maccatalyst

These can now be specified the -target argument to gomobile, e.g.: gomobile build -target=ios,iossimulator,macos,maccatalyst

It preserves the current behavior of -target=ios, which will build for ios and iossimulator on supported architectures (arm64 and amd64).

It adds platform-specific build tags so Go code can discriminate between different Apple platforms like maccatalyst (UIKit on macOS).

This PR also fixes a number of broken tests.

TODO: cgo has a bug where c-archive builds targeting Catalyst will fail unless -tags=ios is supplied. See https://golang.org/issues/47228

Fixes https://golang.org/issues/47212 Updates https://golang.org/issues/47228

Add support for macOS (non-Catalyst) and Catalyst targets.

The compiled library is packaged into a "fat" XCFramework file (as opposed to a Framework), which includes binaries for iOS, macOS, MacCatalyst (iOS on macOS), and iOS Simulator targets, for amd64 and arm64 architectures.

The generated XCFramework file is suitable for distribution as a binary Swift Package Manager package: https://developer.apple.com/documentation/swift_packages/distributing_binary_frameworks_as_swift_packages

This change is based on earlier work: https://github.com/golang/mobile/pull/45 https://github.com/golang/mobile/pull/63

Fixes golang/go#36856

Go install requires a version to be provided after the package name. gomobile init command is updated to reflect this new requirement

Fixes golang/go#50994

As of macOS 10.15 target catalyst can be used to build an iPad app to run on macOS. Existing .Framework built with gomobile produces the following error when targetting catalyst:

error: Building for Mac Catalyst, but the linked framework 'Sample.framework' was built for iOS + iOS Simulator.
You may need to restrict the platforms for which this framework should be linked in the target editor, or replace it with an XCFramework that supports both platforms. (in target 'MySampleApp' from project 'MySampleApp')

~~This PR adds a case for catalyst (although architecture is just amd64) when configuring the environment for each architecture, providing the flags needed to enable the built .Framework to be used with catalyst.~~

Fixes https://github.com/golang/go/issues/36856

Update 18-Jan-2021

This PR has been updated to provide nominally working support of .xcframework generation with go1.15, which has removed support for some 32 bit architectures. See: https://github.com/dpwiese/mobile/pull/1#issuecomment-761931422. In addition, unlike https://github.com/dpwiese/mobile/pull/1 this PR doesn't require manual thinning or combining of the generated .frameworks for each of the various "architectures" - this is now done automatically.

Todo Running go test fails with the following.

bind_test.go:321: gomobile bind failed: exit status 1
    /var/folders/rx/h40bjl5n0s1fvr5h2w278tm80000gn/T/gomobile-test335293790/gomobile: darwin-catalyst: go build -tags ios -buildmode=c-archive -o /var/folders/rx/h40bjl5n0s1fvr5h2w278tm80000gn/T/gomobile-work-224727912/Cgopkg-amd64.a ./gobind failed: exit status 1
    go: cannot determine module path for source directory /private/var/folders/rx/h40bjl5n0s1fvr5h2w278tm80000gn/T/gomobile-work-224727912/src (outside GOPATH, module path must be specified)

Note: on current master branch TestIOSBuild fails

This highly improves interop with Swift. It would map all pointers as implicitly unwrapped optionals, which skip all null safety checks. Adding _Nullable to pointer types makes swift map them as optionals.

Also constructors are now nullable since it's valid to return nil from Go code.

This PR is derived from golang/mobile#45 .

I changed the build process and it will create 3 frameworks for ios, simulator and catalyst. Every framework has a fat library contains both arm64 and x86_64 (except ios that only needs arm64).

Finally create one xcframework from all 3 fat frameworks and this xcframework contains every platform and architecture.

The check when looking for android platform is unnecessarily stringent in that the error would be caught by the call to os.Stat, and it fails when the android platform folder is a symlink, which is the case when developing on NixOs.

Add an example Swift package built with gomobile for multiple Apple platforms (ios, iosimulator, macos, and maccatalyst).

It builds an XCFramework file which is linked as a binary dependency by Swift Package Manager. The resulting Swift package can be imported into an iOS, macOS, or Catalyst app and called from Swift.

It has tests written in Swift. To run the tests, run swift test from the example/swift-package directory.

Depends on golang.org/cl/334689 (golang/mobile#70).

Previously any library created using gobind used reflection to get the ApplicationContext. The methods used are disallowed in Android 9 causing any library to crash. However the ApplictionContext is not required and only needed when using RunOnJvm. This change adds an method to set the ApplicationContext when needed, but will not get it by default by using reflection.

Fixes #31364

This updates examples for the changes in golang.org/cl/334689 for .xcframework files and Mac Catalyst.

Depends on golang.org/cl/334689

https://go-review.googlesource.com/c/mobile/+/334689/28/example/bind/ios/README#1

Talked with @waylybaye offline, I decided to continue #63 and #45.

@waylybaye:

I changed the build process and it will create 3 frameworks for ios, simulator and catalyst. Every framework has a fat library contains both arm64 and x86_64 (except ios that only needs arm64).

Finally create one xcframework from all 3 fat frameworks and this xcframework contains every platform and architecture.

Review comments at https://go-review.googlesource.com/c/mobile/+/288752 should be mostly resolved.

To "make sure gobind is up to date", runInit calls goInstall with "golang.org/x/mobile/cmd/gobind@latest" . But it shouldn't have "@latest". This instruction can replace the gobind command in the user's $GOPATH/bin with an unexpected version. Also, it is possible that "@latest" has a breaking change with the user's application. It is better to call goInstall without "@latest" so that it will follow the directives in the user's go.mod file.

Currently some installations of Xcode and Command Line Tools cause warnings about missing extensions which break parsing of paths returned from xcrun that gomobile depends on resulting in errors like this:

cgo: C compiler "2022-09-07" not found: exec: "2022-09-07": executable file not found in $PATH

This is caused by these warnings returned on stdout by xcrun:

 > xcrun --find clang
2022-09-07 14:50:13.907 xcodebuild[69942:386823822] Requested but did not find extension point with identifier Xcode.IDEKit.ExtensionSentinelHostApplications for extension Xcode.DebuggerFoundation.AppExtensionHosts.watchOS of plug-in com.apple.dt.IDEWatchSupportCore
2022-09-07 14:50:13.908 xcodebuild[69942:386823822] Requested but did not find extension point with identifier Xcode.IDEKit.ExtensionPointIdentifierToBundleIdentifier for extension Xcode.DebuggerFoundation.AppExtensionToBundleIdentifierMap.watchOS of plug-in com.apple.dt.IDEWatchSupportCore
2022-09-07 14:50:14.041 xcodebuild[69942:386823822] XType: com.apple.fonts is not accessible.
2022-09-07 14:50:14.041 xcodebuild[69942:386823822] XType: XTFontStaticRegistry is enabled.
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang

Resulting in gomobile interpreting the date 2022-09-07 as Clang compiler.

Resolves: https://github.com/golang/go/issues/53316

Consider the following Go code with a method that returns a byte array and an error:

package example

type TestClass struct {
}
func (req *TestClass) GetData() ([]byte, error) {
        return nil, nil
}

gobind creates an Objective-C method which returns NSData* and an error:

- (NSData* _Nullable)getData:(NSError* _Nullable* _Nullable)error {
    ....
}

The method signature seen by Swift is func getData() throws -> Data . The problem is that Data is not optional, and when the Objective-C method returns NULL the program crashes. This is the default signature as explained in the Swift documentation: https://clang.llvm.org/docs/AttributeReference.html#swift-error

But this is not appropriate for gobind since it is valid for Go to return a nil value. We don't want the crash. This pull request updates asSignature so that if the method returns an error and the method returns a nullable pointer to NSData or NSString, then add the nonnull_error attribute as explained in the Swift documentation.

With this attribute, the method signature seen by Swift is func getData() throws -> Data? . When the Go function returns nil, it is returned as a nil optional value without crashing.

Fixed a line break/seperator. Line break/seperator is added by 3 hyphens --- but in the previous README it was just 2 hyphens -- It ain't much, but it's honest work.

I think this change (https://github.com/fyne-io/fyne/pull/2956) should be added to gomobile too, it is only 2 rows of imports and 2 rows to release memory if Android OS send onLowMemory signal ...