Ios – What are the libraries linking options in Xcode

binaryframeworksioslibrariesxcode

As of Xcode 7, there are some library/framework linking options in Xcode

Go to application Target in project tab

General -> Embedded Binaries
General -> Link Frameworks and Libraries
Build Phases -> Target Dependencies
Build Phases -> Link Binary with Libraries

Here are a few ways I found

Using Alamofire shows Embedded Binaries option

The Alamofire.framework is automagically added as a target dependency, linked framework and embedded framework in a copy files build phase which is all you need to build on the simulator and a device.

Creating your first iOS Framework shows that adding the Library.xcodeproj into workspace, then Build Phases -> Link Binary with Libraries
Carthage Tutorial: Getting Started shows that dragging Library.framework into General -> Link Frameworks and Libraries. It seems General -> Link Frameworks and Libraries and Build Phases -> Link Binary with Libraries are the same
Carthage seems to differentiate between iOS and OS X.

If you're building for OS X: On your application targets’ “General”
settings tab, in the “Embedded Binaries” section, drag and drop each
framework you want to use from the Carthage/Build folder on disk.

If you're building for iOS, tvOS, or watchOS: On your application
targets’ “General” settings tab, in the “Linked Frameworks and
Libraries” section, drag and drop each framework you want to use from
the Carthage/Build folder on disk.

Reading Linking to a Library or Framework, we know that these options are about linking a framework into our application/framework.

But what are the differences between them? Is any single option a catch all for all of them?

Best Answer

For dynamic frameworks built with carthage I usually use this setup:

Link the library with any target you want to use it in. You need this to be able to import the framework in your code.
Embed the library only in the containing app target. This will actually copy the framework in your app bundle. If you don't embed it your app will crash on startup, because your framework can't be found.

Only the app target is responsible for embedding all the frameworks and their dependencies. That way if an extension and the app both use a framework, it will be distributed with the app only once.

For the Xcode interface:

dragging a framework into General -> Embedded Binaries will add the framework to both "Link Binary With Libraries" and "Embed Frameworks" build phases
dragging a framework into General -> Linked Frameworks and Libraries will add the framework only to the "Link Binary With Libraries" build phase.

The views under General seem to be filled from the build phases tab so you can use either.

Hope that makes sense.

Edit: Target dependencies are just targets that need to be built before the current target can be built. So your app target would list its extension here, so that the extension gets built, whenever you build your app.

Related Solutions

The difference between a framework and a library

A library performs specific, well-defined operations.

A framework is a skeleton where the application defines the "meat" of the operation by filling out the skeleton. The skeleton still has code to link up the parts but the most important work is done by the application.

Examples of libraries: Network protocols, compression, image manipulation, string utilities, regular expression evaluation, math. Operations are self-contained.

Examples of frameworks: Web application system, Plug-in manager, GUI system. The framework defines the concept but the application defines the fundamental functionality that end-users care about.

Python – What does the ‘b’ character do in front of a string literal

Python 3.x makes a clear distinction between the types:

str = '...' literals = a sequence of Unicode characters (Latin-1, UCS-2 or UCS-4, depending on the widest character in the string)
bytes = b'...' literals = a sequence of octets (integers between 0 and 255)

If you're familiar with:

Java or C#, think of str as String and bytes as byte[];
SQL, think of str as NVARCHAR and bytes as BINARY or BLOB;
Windows registry, think of str as REG_SZ and bytes as REG_BINARY.

If you're familiar with C(++), then forget everything you've learned about char and strings, because a character is not a byte. That idea is long obsolete.

You use str when you want to represent text.

print('שלום עולם')

You use bytes when you want to represent low-level binary data like structs.

NaN = struct.unpack('>d', b'\xff\xf8\x00\x00\x00\x00\x00\x00')[0]

You can encode a str to a bytes object.

>>> '\uFEFF'.encode('UTF-8')
b'\xef\xbb\xbf'

And you can decode a bytes into a str.

>>> b'\xE2\x82\xAC'.decode('UTF-8')
'€'

But you can't freely mix the two types.

>>> b'\xEF\xBB\xBF' + 'Text with a UTF-8 BOM'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't concat bytes to str

The b'...' notation is somewhat confusing in that it allows the bytes 0x01-0x7F to be specified with ASCII characters instead of hex numbers.

>>> b'A' == b'\x41'
True

But I must emphasize, a character is not a byte.

>>> 'A' == b'A'
False

In Python 2.x

Pre-3.0 versions of Python lacked this kind of distinction between text and binary data. Instead, there was:

unicode = u'...' literals = sequence of Unicode characters = 3.x str
str = '...' literals = sequences of confounded bytes/characters
- Usually text, encoded in some unspecified encoding.
- But also used to represent binary data like struct.pack output.

In order to ease the 2.x-to-3.x transition, the b'...' literal syntax was backported to Python 2.6, in order to allow distinguishing binary strings (which should be bytes in 3.x) from text strings (which should be str in 3.x). The b prefix does nothing in 2.x, but tells the 2to3 script not to convert it to a Unicode string in 3.x.

So yes, b'...' literals in Python have the same purpose that they do in PHP.

Also, just out of curiosity, are there more symbols than the b and u that do other things?

The r prefix creates a raw string (e.g., r'\t' is a backslash + t instead of a tab), and triple quotes '''...''' or """...""" allow multi-line string literals.

Best Answer

Related Solutions

The difference between a framework and a library

Python – What does the ‘b’ character do in front of a string literal

In Python 2.x

Related Topic