Carthage / Carthage

Carthage ma być najprostszym sposobem na dodanie frameworków do twojej aplikacji Cocoa.

Carthage buduje twoje zależności i dostarcza ci binarne frameworki, ale zachowujesz pełną kontrolę nad strukturą projektu i ustawieniami. Kartagina nie modyfikuje automatycznie plików projektu ani ustawień budowania.

• Szybki start
• Instalacja Carthage
• Dodawanie frameworków do aplikacji
  • Początek
    • Budowanie niezależnych od platformyniezależnych od platformy XCFrameworks
      • Migracja projektu z frameworków do XCFrameworks
    • Budowanie frameworków specyficznych dla platformy
      • Jeśli budujesz dla macOS
      • Jeśli budujesz dla iOS, tvOS, lub watchOS
    • Dla wszystkich platform
    • (Opcjonalnie) Dodaj fazę budowania, aby ostrzec o nieaktualnych zależnościach
    • Zgodność pobierania frameworków binarnych Swift

    .

  • Uruchamianie projektu, który używa Carthage
  • Dodawanie frameworków do testów jednostkowych lub frameworków
  • Uaktualnianie frameworków
    • Experimental Resolver
  • Zagnieżdżone zależności
  • Używanie submodułów dla zależności
  • Automatyczna przebudowa zależności
  • Buforowanie kompilacji
  • Uzupełnianie Bash/Zsh/Fish
• Wspieranie Carthage dla Twojego frameworka
  • Udostępniaj swoje schematy Xcode
  • Rozwiązuj błędy kompilacji
  • Taguj stabilne wydania
  • Archiwizuj prebuilowane frameworki w jeden plik zip
    • Użyj travis-ci, aby przesłać swoje oznaczone prefabrykowane frameworki
  • Buduj statyczne frameworki, aby przyspieszyć czas uruchamiania aplikacji
  • Deklaruj swoją kompatybilność
• Znane problemy
  • Problem z symbolami DWARF
• CarthageKit
• Różnice pomiędzy Carthage i CocoaPods
• Licencja

Szybki start

1. Pobierz Carthage uruchamiając brew install carthage lub wybierz inną metodę instalacji

2. Utwórz Cartfile w tym samym katalogu, w którym znajduje się Twój .xcodeproj lub .xcworkspace

3. Wymień żądane zależności w Cartfile, na przykład:

   github "Alamofire/Alamofire" ~> 4.7.2

4. Run carthage update --use-xcframeworks

5. Plik Cartfile.resolved i katalog Carthage pojawią się w tym samym katalogu, w którym znajduje się Twój .xcodeproj lub .xcworkspace

6. Przeciągnij zbudowane .xcframework bundle z Carthage/Build do sekcji „Frameworks and Libraries” w projekcie Xcode Twojej aplikacji.

7. Jeśli używasz Carthage dla aplikacji, wybierz „Osadź & Znak”, w przeciwnym razie „Nie osadzaj”.

Aby uzyskać szczegółowy przewodnik, przeczytaj dalej Dodawanie frameworków do aplikacji

Instalowanie Carthage

Istnieje wiele opcji instalacji Carthage:

• Instalator: Pobierz i uruchom plik Carthage.pkg dla najnowszego wydania, a następnie postępuj zgodnie z instrukcjami wyświetlanymi na ekranie. Jeśli instalujesz pkg przez CLI, być może będziesz musiał najpierw uruchomić sudo chown -R $(whoami) /usr/local.

• Homebrew: Możesz użyć Homebrew i zainstalować narzędzie carthage w swoim systemie po prostu uruchamiając brew update i brew install carthage. (Uwaga: jeśli wcześniej zainstalowałeś binarną wersję Kartaginy, powinieneś usunąć /Library/Frameworks/CarthageKit.framework).

• MacPorty: Możesz użyć MacPorts i zainstalować narzędzie carthage w swoim systemie po prostu uruchamiając sudo port selfupdate i sudo port install carthage. (Uwaga: jeśli wcześniej zainstalowałeś binarną wersję Carthage, powinieneś usunąć /Library/Frameworks/CarthageKit.framework).

• Zródło: Jeśli chciałbyś uruchomić najnowszą wersję rozwojową (która może być wysoce niestabilna lub niekompatybilna), po prostu sklonuj gałąź master repozytorium, a następnie uruchom make install. Wymaga Xcode 10.0 (Swift 4.2).

Dodawanie frameworków do aplikacji

Po zainstalowaniu Carthage możesz zacząć dodawać frameworki do swojego projektu. Zauważ, że Carthage obsługuje tylko dynamiczne frameworki, które są dostępne tylko na iOS 8 lub nowszym (lub dowolnej wersji OS X).

Początek

Tworzenie niezależnych od platformy frameworków XCFrameworks (Xcode 12 i nowsze)

1. Utwórz plik Cartfile, który zawiera listę frameworków, których chcesz użyć w swoim projekcie.
2. Uruchom carthage update --use-xcframeworks. Spowoduje to pobranie zależności do folderu Carthage/Checkouts i zbudowanie każdej z nich lub pobranie prekompilowanego XCFramework.
3. Na karcie Ogólne ustawienia celów aplikacji, w sekcji Frameworks, Libraries i Embedded Content, przeciągnij i upuść każdy XCFramework, którego chcesz użyć z folderu Carthage/Build na dysku.

Migracja projektu z pakietów frameworków do XCFrameworks

Zachęcamy do używania XCFrameworks od wersji 0.37.0 (styczeń 2021) i wymagamy XCFrameworks podczas budowania na Apple Silicon Mac. Przejście z dyskretnych pakietów frameworków na XCFrameworks wymaga kilku zmian w twoim projekcie:

Kroki migracji

1. Usuń swój folder Carthage/Build, aby usunąć wszelkie istniejące pakiety frameworków.
2. Buduj nowe XCFrameworks, uruchamiając carthage build --use-xcframeworks. Wszelkie inne argumenty, z którymi budujesz, mogą być podane jak zwykle.
3. Usuń odniesienia do starych frameworków w każdym z twoich celów:
   • Usuń odniesienia do frameworków Carthage z sekcji Frameworks, Libraries, and Embedded Content celu i/lub jego fazy budowania Link Binary with Libraries.
   • Usuń odniesienia do frameworków Carthage z wszelkich faz budowania Copy Files.
   • Usuń fazę budowania carthage copy-frameworks celu, jeśli jest obecna.
4. Dodaj odniesienia do XCFrameworks w każdym z twoich celów:
   • Dla celu aplikacji: W zakładce Ustawienia ogólne, w sekcji Frameworks, Libraries, and Embedded Content, przeciągnij i upuść każdy XCFramework, którego używasz z folderu Carthage/Build na dysku.
   • Dla docelowego frameworka: W zakładce Build Phases, w fazie Link Binary with Libraries, przeciągnij i upuść każdy XCFramework, którego używasz z folderu Carthage/Build na dysku.

Building platform-specific framework bundles (default for Xcode 11 and below)

Kompatybilność z Xcode 12+: Platformy wieloarchitektoniczne nie są obsługiwane podczas budowania wiązek frameworków w Xcode 12 i wyżej. Preferuj budowanie za pomocą XCFrameworks. Jeśli musisz zbudować dyskretne pakiety frameworków, użyj obejścia w postaci pliku xcconfig.

Jeśli budujesz dla macOS

instrukcje specyficzne dla macOS

1. Utwórz plik Cartfile, który zawiera listę frameworków, których chcesz użyć w swoim projekcie.
2. Uruchom carthage update --platform macOS. Spowoduje to pobranie zależności do folderu Carthage/Checkouts i zbudowanie każdej z nich lub pobranie prekompilowanego frameworka.
3. Na karcie Ogólne ustawienia celów aplikacji, w sekcji Wbudowane pliki binarne, przeciągnij i upuść każdy framework, którego chcesz użyć z folderu Carthage/Build na dysku.

Dodatkowo będziesz musiał skopiować symbole debugowania do debugowania i raportowania awarii w systemie OS X.

1. Na karcie Ustawienia faz budowania w docelowej aplikacji kliknij ikonę + i wybierz opcję Nowa faza kopiowania plików.
2. Kliknij menu rozwijane Miejsce docelowe i wybierz Katalog produktów.
3. Dla każdego używanego frameworka przeciągnij i upuść odpowiedni plik dSYM.

Jeśli budujesz dla iOS, tvOS lub watchOS

Instrukcje specyficzne dla platformy

1. Utwórz plik Cartfile, który zawiera listę frameworków, których chcesz użyć w swoim projekcie.

2. Uruchom carthage update. Spowoduje to pobranie zależności do folderu Carthage/Checkouts, a następnie zbudowanie każdego z nich lub pobranie wstępnie skompilowanego frameworka.

3. Otwórz zakładkę Ustawienia ogólne swoich celów aplikacji. W przypadku Xcode 11.0 i nowszych, w sekcji „Frameworks, Libraries, and Embedded Content” przeciągnij i upuść każdy framework, którego chcesz użyć z folderu Carthage/Build na dysku. Następnie, w sekcji „Osadzanie”, wybierz „Nie osadzaj” z menu rozwijanego dla każdego dodanego elementu. W przypadku Xcode 10.x i niższych, w sekcji „Połączone frameworki i biblioteki” przeciągnij i upuść każdy framework, którego chcesz użyć z folderu Carthage/Build na dysku.

4. Na karcie Ustawienia faz budowania celów aplikacji, kliknij ikonę + i wybierz Nowa faza skryptu uruchamiania. Utwórz skrypt uruchamiania, w którym określasz swoją powłokę (np. /bin/sh), dodaj następującą zawartość do obszaru skryptu poniżej powłoki:

   /usr/local/bin/carthage copy-frameworks

5. Utwórz plik o nazwie input.xcfilelist i plik o nazwie output.xcfilelist

6. Dodaj ścieżki do frameworków, których chcesz użyć do input.xcfilelist. Na przykład:

   $(SRCROOT)/Carthage/Build/iOS/Result.framework$(SRCROOT)/Carthage/Build/iOS/ReactiveSwift.framework$(SRCROOT)/Carthage/Build/iOS/ReactiveCocoa.framework

7. Dodaj ścieżki do skopiowanych frameworków do output.xcfilelist. Na przykład:

   $(BUILT_PRODUCTS_DIR)/$(FRAMEWORKS_FOLDER_PATH)/Result.framework$(BUILT_PRODUCTS_DIR)/$(FRAMEWORKS_FOLDER_PATH)/ReactiveSwift.framework$(BUILT_PRODUCTS_DIR)/$(FRAMEWORKS_FOLDER_PATH)/ReactiveCocoa.framework

   Z plikami wyjściowymi określonymi obok plików wejściowych, Xcode musi uruchomić skrypt tylko wtedy, gdy pliki wejściowe uległy zmianie lub brakuje plików wyjściowych. Oznacza to, że brudne kompilacje będą szybsze, jeśli nie przebudowałeś frameworków za pomocą Carthage.

8. Dodaj input.xcfilelistdo sekcji „Listy plików wejściowych” w fazie skryptu uruchamianego z Carthage

9. Dodaj output.xcfilelistdo sekcji „Listy plików wyjściowych” w fazie skryptu uruchamianego z Carthage

Skrypt ten rozwiązuje problem błędu zgłaszania do App Store wywołanego przez uniwersalne binarki i zapewnia, że niezbędne pliki związane z bitcode i dSYM są kopiowane podczas archiwizacji.

Po skopiowaniu informacji o debugowaniu do katalogu zbudowanych produktów, Xcode będzie w stanie symbolizować ślad stosu za każdym razem, gdy zatrzymasz się w punkcie przerwania. Umożliwi to również przejście przez kod innych firm w debugerze.

Podczas archiwizowania aplikacji w celu przesłania jej do App Store lub TestFlight, Xcode skopiuje również te pliki do podkatalogu dSYMs w pakiecie .xcarchive aplikacji.

Dla wszystkich platform

Po drodze, Carthage utworzy pewne artefakty budowy. Najważniejszym z nich jest plik Cartfile.resolved, który zawiera listę wersji, które zostały faktycznie zbudowane dla każdego frameworka. Upewnij się, że zatwierdziłeś swój Cartfile.resolved, ponieważ każdy inny użytkownik projektu będzie potrzebował tego pliku, aby zbudować te same wersje frameworka.

(Opcjonalnie) Dodaj fazę budowania, aby ostrzegać o nieaktualnych zależnościach

Możesz dodać fazę skryptu uruchomieniowego, aby automatycznie ostrzegać, gdy jedna z twoich zależności jest nieaktualna.

1. Na karcie ustawień Build Phases celów aplikacji, kliknij ikonę + i wybierz New Run Script Phase. Utwórz skrypt uruchomieniowy, w którym określasz swoją powłokę (np. /bin/sh), dodaj następującą zawartość do obszaru skryptu poniżej powłoki:

/usr/local/bin/carthage outdated --xcode-warnings 2>/dev/null

Zgodność pobranych frameworków binarnych Swift

Carthage sprawdzi, czy pobrane frameworki Swift (i mieszane Objective-C/Swift) zostały zbudowane z tą samą wersją Swift, która jest używana lokalnie. Jeśli istnieje niedopasowanie wersji, Carthage przystąpi do budowania frameworka ze źródła. Jeśli framework nie może być zbudowany ze źródła, Carthage zawiedzie.

Ponieważ Carthage używa wyjścia xcrun swift --version do określenia lokalnej wersji Swifta, upewnij się, że uruchamiasz polecenia Carthage z zestawem narzędzi Swift, którego zamierzasz używać. Dla wielu przypadków użycia, nic dodatkowego nie jest potrzebne. Jednak na przykład, jeśli budujesz projekt Swift 2.3 przy użyciu Xcode 8.x, jednym z podejść do określenia domyślnego swift dla carthage bootstrap jest użycie następującego polecenia:

TOOLCHAINS=com.apple.dt.toolchain.Swift_2_3 carthage bootstrap

Uruchamianie projektu, który używa Carthage

Po wykonaniu powyższych kroków i przesłaniu zmian, inni użytkownicy projektu muszą tylko pobrać repozytorium i uruchomić carthage bootstrap, aby rozpocząć pracę z dodanymi frameworkami.

Dodawanie frameworków do testów jednostkowych lub frameworków

Używanie Carthage do zależności dowolnego celu jest dość podobne do używania Carthage dla aplikacji. Główna różnica polega na tym, w jaki sposób frameworki są faktycznie skonfigurowane i połączone w Xcode.

Ponieważ cele testów jednostkowych nie mają sekcji Połączone frameworki i biblioteki w zakładce Ustawienia ogólne, musisz zamiast tego przeciągnąć zbudowane frameworki do fazy budowania Link Binaries With Libraries.

W celu testowym w zakładce Ustawienia budowania, dodaj @loader_path/Frameworks do ścieżki wyszukiwania Runpath, jeśli jeszcze jej nie ma.

W rzadkich przypadkach, możesz również chcieć skopiować każdą zależność do produktu budowania (np, aby osadzić zależności w zewnętrznym frameworku, lub upewnić się, że zależności są obecne w pakiecie testowym). Aby to zrobić, należy utworzyć nową fazę budowania Copy Files z miejscem docelowym Frameworks, a następnie dodać tam również referencje do frameworków. Nie powinieneś używać polecenia carthage copy-frameworks, ponieważ pakiety testowe nie wymagają usuwania frameworków, a równoległe uruchamianie instancji copy-frameworks (z włączonym równoległym budowaniem) nie jest obsługiwane.

Uaktualnianie frameworków

Jeśli zmodyfikowałeś swój Cartfile lub chcesz uaktualnić do najnowszych wersji każdego frameworka (zgodnie z wymaganiami, które określiłeś), po prostu uruchom ponownie polecenie carthage update.

Jeśli chcesz zaktualizować tylko jedną lub konkretne zależności, przekaż je jako listę oddzieloną spacjami do polecenia update. np.

carthage update Box

lub

carthage update Box Result

Experimental Resolver

Przepisanie logiki aktualizacji frameworków zostało dokonane w celu zwiększenia szybkości i zmniejszenia zużycia pamięci. Jest to obecnie funkcja typu opt-in. Można jej użyć przekazując --new-resolver do polecenia aktualizacji, np.,

carthage update --new-resolver Box

Jeśli doświadczasz problemów z wydajnością podczas aktualizacji, wypróbuj nowy resolver

Zależności zagnieżdżone

Jeśli framework, który chcesz dodać do swojego projektu ma zależności wyraźnie wymienione w pliku Cartfile, Carthage automatycznie pobierze je dla Ciebie. Następnie będziesz musiał sam przeciągnąć je do swojego projektu z folderu Carthage/Build.

Jeśli wbudowany framework w twoim projekcie ma zależności do innych frameworków, musisz połączyć je z celem aplikacji (nawet jeśli cel aplikacji nie ma zależności do tych frameworków i nigdy ich nie używa).

Używanie submodułów dla zależności

Domyślnie, Kartagina będzie bezpośrednio sprawdzać pliki źródłowe zależności do folderu projektu, pozostawiając Ci możliwość ich zatwierdzenia lub zignorowania według Twojego uznania. Jeśli chcesz, aby zamiast tego zależności były dostępne jako submoduły Git (być może po to, abyś mógł w nich wprowadzać zmiany), możesz uruchomić carthage update lub carthage checkout z flagą --use-submodules.

Po uruchomieniu w ten sposób, Carthage będzie pisać do plików .gitmodules i .git/config Twojego repozytorium i automatycznie aktualizować submoduły, gdy zmienią się wersje zależności.

Automatyczne przebudowywanie zależności

Jeśli chcesz pracować nad swoimi zależnościami podczas rozwoju i chcesz, aby były one automatycznie przebudowywane podczas budowania projektu nadrzędnego, możesz dodać fazę budowania Run Script, która wywołuje Carthage w następujący sposób:

/usr/local/bin/carthage build --platform "$PLATFORM_NAME" --project-directory "$SRCROOT"

Zauważ, że powinieneś używać submodułów zanim to zrobisz, ponieważ zwykłe checkouty nie powinny być modyfikowane bezpośrednio.

Buforowanie buildów

Domyślnie Carthage przebuduje zależność niezależnie od tego, czy jest to ta sama rozwiązana wersja co poprzednio. Przekazanie --cache-builds spowoduje, że carthage uniknie przebudowy zależności, jeśli będzie to możliwe. Zobacz informacje o plikach wersji, aby dowiedzieć się, jak Carthage wykonuje to buforowanie.

Uwaga: W tym czasie --cache-builds jest niekompatybilne z --use-submodules. Użycie obu spowoduje, że kopia robocza i zmiany w zależnościach twojego submodułu nie zostaną poprawnie przebudowane. Zobacz #1785 po szczegóły.

Uzupełnianie Bash/Zsh/Fish

Automatyczne uzupełnianie poleceń i opcji Carthage jest dostępne jak udokumentowano w Bash/Zsh/Fish Completion.

Obsługa Carthage dla Twojego frameworka

Carthage oficjalnie obsługuje tylko dynamiczne frameworki. Dynamiczne frameworki mogą być używane na każdej wersji OS X, ale tylko na iOS 8 lub nowszym. Dodatkowo, od wersji 0.30.0 Carthage obsługuje statyczne frameworki.

Ponieważ Carthage nie ma scentralizowanej listy pakietów, ani formatu specyfikacji projektu, większość frameworków powinna budować się automatycznie.

Specyficzne wymagania każdego projektu frameworka są wymienione poniżej.

Udostępnij swoje schematy Xcode

Carthage zbuduje tylko te schematy Xcode, które są udostępnione z Twojego .xcodeproj. Możesz sprawdzić, czy wszystkie zamierzone schematy zostały zbudowane pomyślnie, uruchamiając carthage build --no-skip-current, a następnie sprawdzając folder Carthage/Build.

Jeśli ważny schemat nie został zbudowany po uruchomieniu tego polecenia, otwórz Xcode i upewnij się, że schemat jest oznaczony jako udostępniony, aby Carthage mógł go odkryć.

Rozwiązywanie błędów budowania

Jeśli napotkasz błędy budowania w carthage build --no-skip-current, spróbuj uruchomić xcodebuild -scheme SCHEME -workspace WORKSPACE build lub xcodebuild -scheme SCHEME -project PROJECT build (z rzeczywistymi wartościami) i zobacz, czy ten sam błąd występuje tam. To powinno przynieść wystarczająco dużo informacji, aby rozwiązać problem.

Jeśli masz zainstalowanych kilka wersji narzędzi deweloperskich Apple (na przykład Xcode beta), użyj xcode-select, aby zmienić wersję, której używa Carthage.

Jeśli nadal nie jesteś w stanie zbudować swojego frameworka z Carthage, otwórz problem, a my z przyjemnością pomożemy!

Znaczniki stabilnych wydań

Carthage określa, które wersje Twojego frameworka są dostępne, przeszukując znaczniki opublikowane w repozytorium i próbując interpretować każdą nazwę znacznika jako semantyczną wersję. Na przykład, w tagu v1.2, semantyczna wersja to 1.2.0.

Tagi bez numeru wersji lub z dowolnymi znakami po numerze wersji (np, 1.2-alpha-1) są obecnie nieobsługiwane i będą ignorowane.

Archiwizacja gotowych frameworków w jednym pliku zip

Carthage może automatycznie używać gotowych frameworków, zamiast budować je od zera, jeśli są dołączone do wydania GitHub Release na repozytorium Twojego projektu lub poprzez binarny plik definicji projektu.

Aby zaoferować wbudowane frameworki dla konkretnego tagu, pliki binarne dla wszystkich obsługiwanych platform powinny być spakowane razem w jedno archiwum, a to archiwum powinno być dołączone do opublikowanego wydania odpowiadającego temu tagowi. Załącznik powinien zawierać .framework w swojej nazwie (np., ReactiveCocoa.framework.zip), aby wskazać Kartaginie, że zawiera binarki. Struktura katalogów w archiwum jest dowolna, ale frameworki powinny pojawić się w archiwum tylko raz, ponieważ zostaną skopiowane do Carthage/Build/<platform> na podstawie ich nazwy (np. ReactiveCocoa.framework).

Operację archiwizacji można wykonać w samym carthage używając:

-carthage build --no-skip-current-carthage archive YourFrameworkName

lub alternatywnie

carthage build --archive

Draft Releases będą automatycznie ignorowane, nawet jeśli odpowiadają żądanemu tagowi.

Użyj travis-ci do wgrania swoich tagowanych prebuilowanych frameworków

Możliwe jest użycie travis-ci w celu zbudowania i wgrania swoich tagowanych wydań.

1. Zainstaluj travis CLI za pomocą gem install travis

2. Skonfiguruj travis-ci dla swojego repozytorium (Krok 1 i 2)

3. Utwórz plik .travis.yml w korzeniu swojego repozytorium w oparciu o ten szablon. Ustaw FRAMEWORK_NAME na właściwą wartość.

   Replace PROJECT_PLACEHOLDER i SCHEME_PLACEHOLDER

   Jeśli używasz przestrzeni roboczej zamiast projektu usuń linię xcode_project i odkomentuj linię xcode_workspace.

   Projekt powinien mieć format: MyProject.xcodeproj

   Przestrzeń robocza powinna być w formacie: MyWorkspace.xcworkspace

   Możesz swobodnie zaktualizować wartość xcode_sdk do innego SDK, zauważ, że testowanie na iphoneos SDK wymagałoby przesłania tożsamości podpisywania kodu

   Więcej informacji można znaleźć w travis docs for objective-c projects

   language: objective-cosx_image: xcode7.3xcode_project: <PROJECT_PLACEHOLDER># xcode_workspace: <WORKSPACE_PLACEHOLDER>xcode_scheme: <SCHEME_PLACEHOLDER>xcode_sdk: iphonesimulator9.3env: global: - FRAMEWORK_NAME=<THIS_IS_A_PLACEHOLDER_REPLACE_ME>before_install: - brew update - brew outdated carthage || brew upgrade carthagebefore_script: # bootstrap the dependencies for the project # you can remove if you don't have dependencies - carthage bootstrapbefore_deploy: - carthage build --no-skip-current - carthage archive $FRAMEWORK_NAME

4. Run travis setup releases, postępuj zgodnie z dokumentacją tutaj

   To polecenie zakoduje twoje dane uwierzytelniające GitHub w pliku .travis.yml, aby umożliwić travisowi przesłanie wydania do GitHub.comGdy pojawi się monit o plik do przesłania, wpisz $FRAMEWORK_NAME.framework.zip

5. Zaktualizuj sekcję deploy, aby działała na tagach:

   W .travis.yml zlokalizuj:

   on: repo: repo/repo

   I dodaj tags: true i skip_cleanup: true:

   skip_cleanup: trueon: repo: repo/repo tags: true

   To pozwoli travisowi wiedzieć, aby utworzyć wdrożenie, gdy nowy tag zostanie popchnięty i zapobiegnie czyszczeniu przez travisa wygenerowanego pliku zip

Zbuduj statyczne frameworki, aby przyspieszyć czasy uruchamiania aplikacji

Jeśli osadzasz wiele dynamicznych frameworków w swojej aplikacji, jej czasy uruchamiania przed głównym uruchomieniem mogą być dość powolne. Carthage jest w stanie pomóc złagodzić ten problem, budując dynamiczne frameworki jako statyczne frameworki. Statyczne frameworki mogą być połączone bezpośrednio w aplikacji lub połączone w większe dynamiczne frameworki z kilkoma prostymi modyfikacjami przepływu pracy, co może skutkować znacznym skróceniem czasu uruchamiania przed startem głównym.

Carthage 0.30.0 lub nowsza

Od wersji 0.30.0 projekt Carthage rozwija wsparcie dla statycznie połączonych frameworków napisanych w Swift lub Objective-C, dla których wsparcie zostało wprowadzone w Xcode 9.4. Proszę jednak zauważyć, że jest tu mowa konkretnie o frameworkach, stąd Darwin bundle z rozszerzeniem .framework i statycznie połączone archiwa obiektów wewnątrz. Carthage nie obsługuje obecnie schematów bibliotek statycznych, ani nie ma planów wprowadzenia ich obsługi w przyszłości.

Przebieg pracy różni się nieznacznie:

• Wciąż musisz zaznaczyć schematy projektu zgodnego z Carthage jako współdzielone w Product > Scheme > Manage Schemes…, tak jak w przypadku dynamicznych binariów
• Wciąż musisz łączyć się ze statycznymi .frameworków w fazach budowania projektu, tak jak w przypadku dynamicznych binariów

Jednakże:

• W ustawieniach budowania, sekcji Linkowanie, w docelowym Cocoa Framework projektu zgodnego z Carthage, ustaw typ Mach-O na Static Library
• Twoje statycznie połączone frameworki będą budowane pod adresem ./Carthage/Build/$(PLATFORM_NAME)/Static
• Nie powinieneś dodawać żadnych statycznych frameworków jako plików wejściowych/wyjściowych w fazie budowania carthage copy-frameworks

Carthage 0.29.0 lub niższej

Zobacz dokument StaticFrameworks, aby uzyskać szczegółowe informacje.

Proszę zauważyć, że do tego podejścia stosuje się kilka zastrzeżeń:

• Swift static frameworks nie są oficjalnie wspierane przez Apple
• Jest to zaawansowany przepływ pracy, który nie jest wbudowany w Carthage, YMMV

Zgłoś swoją kompatybilność

Chcesz zareklamować, że Twój projekt może być używany z Carthage? Możesz dodać plakietkę zgodności:

… do swojego README, po prostu wstawiając następujący Markdown:

(https://img.shields.io/badge/Carthage-compatible-4BC51D.svg?style=flat)](https://github.com/Carthage/Carthage)

Znane problemy

Problem z symbolem DWARFs

Pre-build framework nie może być debugowany przy użyciu step execution na maszynie innej niż ta, na której został zbudowany. Po prostu carthage bootstrap/build/update --no-use-binaries powinno to naprawić, ale dla bardziej zautomatyzowanego obejścia, zobacz #924. Zduplikuj rdar://23551273, jeśli chcesz, aby Apple naprawiło pierwotną przyczynę tego problemu.

CarthageKit

Większość funkcjonalności carthage narzędzia wiersza poleceń jest w rzeczywistości zamknięta we frameworku o nazwie CarthageKit.

Jeśli jesteś zainteresowany użyciem Carthage jako części innego narzędzia lub rozszerzeniem funkcjonalności Carthage, spójrz na kod źródłowy CarthageKit, aby sprawdzić, czy API pasuje do Twoich potrzeb.

Różnice między Carthage a CocoaPods

CocoaPods to znany od dawna menedżer zależności dla Cocoa. Dlaczego więc stworzono Carthage? Po pierwsze, CocoaPods (domyślnie) automatycznie tworzy i aktualizuje obszar roboczy Xcode dla Twojej aplikacji i wszystkich zależności. Carthage buduje binaria frameworków za pomocą xcodebuild, ale pozostawia odpowiedzialność za ich integrację użytkownikowi. Podejście CocoaPods jest łatwiejsze w użyciu, podczas gdy podejście Carthage jest elastyczne i nieinwazyjne.

Cel CocoaPods jest wymieniony w jego README w następujący sposób:

… aby poprawić odkrywanie i zaangażowanie w biblioteki open-source stron trzecich, tworząc bardziej scentralizowany ekosystem.

Dla kontrastu, Carthage została stworzona jako zdecentralizowany menedżer zależności. Nie ma centralnej listy projektów, co redukuje prace konserwacyjne i pozwala uniknąć centralnego punktu awarii. Jednak odkrywanie projektów jest trudniejsze – użytkownicy muszą korzystać z Trending pages GitHuba lub podobnych.

Projekty CocoaPods muszą również mieć tak zwany plik podspec, który zawiera metadane o projekcie i określa, jak powinien być zbudowany. Carthage używa xcodebuild do budowania zależności, zamiast integrować je w jeden obszar roboczy, nie ma podobnego pliku specyfikacji, ale twoje zależności muszą zawierać swój własny projekt Xcode, który opisuje, jak budować ich produkty.

Ultimately, we created Carthage because we wanted the simplest tool possible – dependency manager that gets the job done without taking over the responsibility of Xcode, and without creating extra work for framework authors. CocoaPods oferuje wiele niesamowitych funkcji, których Carthage nigdy nie będzie miała, kosztem dodatkowej złożoności.

Licencja

Carthage jest wydana na licencji MIT.

Zdjęcie tła nagłówka jest wydane na licencji CC BY-NC-SA 2.0. Oryginalne zdjęcie autorstwa Richarda Mortela.