'
Articles

Carthage / Carthage

author
26 minutes, 5 seconds Read

A Carthage célja, hogy a legegyszerűbb módja legyen a keretrendszerek hozzáadásának a Cocoa alkalmazásodhoz.

A Carthage felépíti a függőségeket és bináris keretrendszereket biztosít, de te megtartod a teljes kontrollt a projekted felépítése és beállítása felett. A Carthage nem módosítja automatikusan a projektfájljait vagy a build beállításait.

  • Gyorstalpaló
  • A Carthage telepítése
  • Keretrendszerek hozzáadása egy alkalmazáshoz
    • Kezdő lépések
      • Platform építése-független XCFrameworks
        • Projekt migrálása keretrendszer-csomagokból az XCFrameworks-be
      • Platformspecifikus keretrendszer-csomagok építése
        • Ha macOS-re épít
        • Ha iOS-re épít, tvOS, vagy watchOS
      • Minden platformra
      • (Opcionálisan) Építési fázis hozzáadása az elavult függőségekre való figyelmeztetéshez
      • Swift bináris keretrendszer letöltési kompatibilitás
    • Karthago-t használó projekt futtatása
    • Keretrendszerek hozzáadása egységtesztekhez vagy egy keretrendszerhez
    • Keretrendszerek frissítése
      • Kísérleti feloldó
    • Beépült függőségek
    • Almodulok használata függőségekhez
    • Automatikusan újraépülő függőségek
    • Caching builds
    • Bash/Zsh/Fish completion
  • Supporting Karthago a keretrendszeredhez
    • Xcode sémáid megosztása
    • Építési hibák megoldása
    • Stabil kiadások címkézése
    • Előre felépített keretrendszerek archiválása egy zip fájlba
      • Travis-használat
        • .ci a címkézett előre felépített keretrendszerek feltöltéséhez
      • Sztatikus keretrendszerek építése az alkalmazás indítási idejének felgyorsítása érdekében
      • Kompatibilitás deklarálása
    • Ismert problémák
      • DWARFs szimbólum probléma
    • CarthageKit
    • Különbségek a Carthage és a CocoaPods
    • Licenc

    Gyorsindítás

    1. Készítsd el a Carthage-ot a brew install carthage futtatásával vagy válassz más telepítési módszert

    2. Készíts egy Cartfile-t ugyanabban a könyvtárban, ahol a .xcodeproj vagy .xcworkspace van

    3. Lista a kívánt függőségeket a Cartfile-ban, például:

      github "Alamofire/Alamofire" ~> 4.7.2

    4. Futtassa a carthage update --use-xcframeworks

    5. Egy Cartfile.resolved fájl és egy Carthage könyvtár fog megjelenni ugyanabban a könyvtárban, ahol a .xcodeproj vagy .xcworkspace

    6. Húzza a felépített .xcframework csomagokat a Carthage/Build-ból az alkalmazás Xcode projektjének “Frameworks and Libraries” szakaszába.

    7. Ha a Carthage-ot használja az alkalmazáshoz, válassza a “Beágyazás & Jelölje be” lehetőséget, ellenkező esetben a “Ne ágyazza be” lehetőséget.

    Egy részletesebb útmutatóért olvassa tovább a Keretrendszerek hozzáadása egy alkalmazáshoz

    A Carthage telepítése

    A Carthage telepítésére több lehetőség is van:

    • Installer: Töltse le és futtassa a Carthage.pkg fájlt a legújabb kiadáshoz, majd kövesse a képernyőn megjelenő utasításokat. Ha a pkg-t CLI-n keresztül telepíti, lehet, hogy először a sudo chown -R $(whoami) /usr/local futtatására lesz szüksége.

    • Homebrew: A Homebrew segítségével egyszerűen telepítheti a carthage eszközt a rendszerére a brew update és a brew install carthage futtatásával. (Megjegyzés: ha korábban telepítette a Karthago bináris verzióját, törölje a /Library/Frameworks/CarthageKit.framework-t.)

    • MacPorts: Használhatja a MacPorts-ot és telepítheti a carthage eszközt a rendszerére egyszerűen a sudo port selfupdate és sudo port install carthage futtatásával. (megjegyzés: ha korábban telepítette a Karthago bináris verzióját, törölje a /Library/Frameworks/CarthageKit.framework-t).

    • A forrásból: Ha a legújabb fejlesztői verziót szeretné futtatni (amely nagyon instabil vagy inkompatibilis lehet), egyszerűen klónozza a repository master ágát, majd futtassa a make install. Xcode 10.0 (Swift 4.2) szükséges hozzá.

    Keretrendszerek hozzáadása egy alkalmazáshoz

    Amint telepítette a Carthage-ot, elkezdheti hozzáadni a keretrendszereket a projektjéhez. Ne feledje, hogy a Carthage csak a dinamikus keretrendszereket támogatja, amelyek csak az iOS 8 vagy újabb operációs rendszeren (vagy az OS X bármely verzióján) érhetőek el.

    Első lépések

    Platformfüggetlen XCFrameworks készítése (Xcode 12 és újabb)

    1. Készítsen egy Cartfile-t, amely felsorolja a projektben használni kívánt keretrendszereket.
    2. Futtassa a carthage update --use-xcframeworks. Ez lehívja a függőségeket egy Carthage/Checkouts mappába, és mindegyiket lefordítja, vagy letölt egy előre lefordított XCFramework-t.
    3. Az alkalmazáscélok Általános beállítások lapján, a Frameworks, Libraries, and Embedded Content szakaszban húzza le a lemezen lévő Carthage/Build mappából minden egyes XCFramework-t, amelyet használni szeretne.
    Projekt áttelepítése a keretrendszer-csomagokról az XCFrameworksre

    Az XCFrameworks használatát a 0.37.0 (2021. január) verziótól kezdve javasoljuk, és az XCFrameworks használatára van szükség, ha Apple Silicon Mac-en építkezik. A diszkrét keretrendszer-csomagokról az XCFrameworks-re való áttérés néhány változtatást igényel a projektjén:

    Az áttérés lépései

    1. Törölje a Carthage/Build mappát, hogy eltávolítsa a meglévő keretrendszer-csomagokat.
    2. Építsen új XCFrameworks-ot a carthage build --use-xcframeworks futtatásával. Minden más argumentumot, amellyel építkezik, a szokásos módon adhat meg.
    3. Törölje a régi keretrendszerekre való hivatkozásokat az egyes célpontokban:
      • Törölje a Carthage keretrendszerekre való hivatkozásokat a célpont Frameworks, Libraries, and Embedded Content szakaszából és/vagy a Link Binary with Libraries építési fázisából.
      • Törölje a Carthage keretrendszerekre való hivatkozásokat bármely Copy Files építési fázisból.
      • Törölje a célpont carthage copy-frameworks építési fázisát, ha van.
    4. Adja hozzá az XCFrameworks-re való hivatkozásokat az egyes célpontokban:
      • Egy alkalmazáscélpont esetében: Az Általános beállítások lapon, a Keretrendszerek, könyvtárak és beágyazott tartalmak szakaszban húzza be a lemezen lévő Carthage/Build mappából az egyes használt XCFrameworks-eket.
      • Keretrendszer-célponthoz: Az Építési fázisok lapon, a Link Binary with Libraries fázisban húzza és dobja be a lemezen lévő Carthage/Build mappából minden egyes használt XCFramework-t.

    Platformspecifikus keretrendszer-csomagok építése (alapértelmezett az Xcode 11 és az alattiak esetében)

    Xcode 12+ inkompatibilitás: A több architektúrájú platformok nem támogatottak az Xcode 12 és újabb keretrendszer-csomagok készítésekor. Előnyben részesíti az XCFrameworks-szel történő építést. Ha diszkrét keretrendszer-csomagokat kell építenie, használjon egy áthidaló xcconfig fájlt.

    Ha macOS-re épít

    macOS-specifikus utasítások

    1. Készítsen egy Cartfile-t, amely felsorolja a projektben használni kívánt keretrendszereket.
    2. Futtassa a carthage update --platform macOS. Ez lehívja a függőségeket egy Carthage/Checkouts mappába, és mindegyiket lefordítja, vagy letölt egy előre lefordított keretrendszert.
    3. Az alkalmazáscélok Általános beállítások lapján, a Beágyazott binárisok szakaszban húzza le a lemezen lévő Carthage/Build mappából az egyes használni kívánt keretrendszereket.

    Kiegészítésképpen a hibakeresés és az OS X-en történő hibajelentés céljából debug szimbólumokat kell másolnia.

    1. Az alkalmazás céljának Build Phases (Építési fázisok) beállításai lapján kattintson a + ikonra, és válassza az New Copy Files Phase (Új fájlok másolása) lehetőséget.
    2. Kattintson a Destination (Cél) legördülő menüre, és válassza a Products Directory (Termékek könyvtára) lehetőséget.
    3. Minden egyes használt keretrendszerhez húzza a megfelelő dSYM fájlt.
    Ha iOS, tvOS vagy watchOS

    Platformspecifikus utasítások

    1. Készítsen egy Cartfile-t, amely felsorolja a projektben használni kívánt keretrendszereket.

    2. Futtassa a carthage update. Ez le fogja hívni a függőségeket egy Carthage/Checkouts mappába, majd mindegyiket lefordítja, vagy letölti az előre lefordított keretrendszereket.

    3. Nyissa meg az alkalmazáscélok Általános beállítások lapját. Az Xcode 11.0 és újabb verziók esetében a “Keretrendszerek, könyvtárak és beágyazott tartalmak” szakaszban húzza le a lemezen lévő Carthage/Build mappából az egyes használni kívánt keretrendszereket. Ezután a “Beágyazás” szakaszban válassza a “Nem beágyazás” lehetőséget a legördülő menüből minden egyes hozzáadott elemhez. Xcode 10.x és alacsonyabb verziók esetén a “Linked Frameworks and Libraries” (Kapcsolódó keretrendszerek és könyvtárak) szakaszba húzza be a lemezen lévő Carthage/Build mappából a használni kívánt keretrendszereket.

    4. Az alkalmazáscélok Build Phases (Építési fázisok) beállításai lapon kattintson a + ikonra, és válassza a New Run Script Phase (Új parancsfázis futtatása) lehetőséget. Hozzon létre egy Futtatási parancsfájlt, amelyben adja meg a héját (pl.: /bin/sh), adja hozzá a következő tartalmat a héj alatti parancsfájlterülethez:

      /usr/local/bin/carthage copy-frameworks

    5. Hozzon létre egy input.xcfilelist nevű fájlt és egy output.xcfilelist

    6. Adja hozzá a input.xcfilelist fájlhoz a használni kívánt keretrendszerek elérési útvonalait. Például:

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

    7. Adja hozzá a másolt keretrendszerek elérési útvonalait a output.xcfilelist fájlhoz. Például:

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

      Mivel a kimeneti fájlok a bemeneti fájlok mellett vannak megadva, az Xcode-nak csak akkor kell futtatnia a szkriptet, ha a bemeneti fájlok megváltoztak, vagy ha a kimeneti fájlok hiányoznak. Ez azt jelenti, hogy a piszkos építések gyorsabbak lesznek, ha nem épített újra keretrendszereket a Karthago segítségével.

    8. Add hozzá a input.xcfilelist-t a Carthage futtatási szkript fázis “Input File Lists” szakaszához

    9. Add hozzá a output.xcfilelist-t a Carthage futtatási szkript fázis “Output File Lists” szakaszához

    Ez a szkript egy univerzális binárisok által kiváltott App Store benyújtási hibát kerül ki, és biztosítja a szükséges bitkóddal kapcsolatos fájlok és dSYM-ek másolását archiváláskor.

    Az épített termékek könyvtárába másolt hibakeresési információkkal az Xcode képes lesz szimbolizálni a stack trace-t, amikor megáll egy töréspontnál. Ez lehetővé teszi azt is, hogy a hibakeresőben végiglépkedjen a harmadik féltől származó kódon.

    Az alkalmazás archiválásakor az App Store-ba vagy a TestFlightba történő benyújtáshoz az Xcode ezeket a fájlokat is bemásolja az alkalmazás .xcarchive csomagjának dSYMs alkönyvtárába.

    Minden platformra

    A Karthago útközben létrehoz néhány építési leletet. Ezek közül a legfontosabb a Cartfile.resolved fájl, amely felsorolja az egyes keretrendszerek ténylegesen épített verzióit. Győződjön meg róla, hogy a Cartfile.resolved fájlt commitolja, mert bárki másnak, aki a projektet használja, szüksége lesz erre a fájlra, hogy ugyanazokat a keretrendszer-verziókat építhesse.

    (Opcionálisan) Építési fázis hozzáadása az elavult függőségekre való figyelmeztetéshez

    Adhat egy Run Script fázist, amely automatikusan figyelmeztet, ha valamelyik függőség elavult.

    1. Az alkalmazáscélok Build Phases beállítások lapján kattintson a + ikonra, és válassza a New Run Script Phase lehetőséget. Hozzon létre egy futtatási parancsfájlt, amelyben megadja a héját (pl.: /bin/sh), a következő tartalommal egészítse ki a parancsfájl területét a héj alatt:
    /usr/local/bin/carthage outdated --xcode-warnings 2>/dev/null

    Swift bináris keretrendszer letöltési kompatibilitás

    A Karthago ellenőrzi, hogy a letöltött Swift (és vegyes Objective-C/Swift) keretrendszerek a Swiftnek a helyileg használt verziójával készültek. Ha nem egyezik a verzió, a Carthage folytatja a keretrendszer forrásból történő építését. Ha a keretrendszer nem építhető forrásból, a Carthage sikertelenül fog működni.

    Mivel a Carthage a xcrun swift --version kimenetét használja a helyi Swift verzió meghatározásához, győződjön meg róla, hogy a Carthage parancsokat a használni kívánt Swift toolchainnel futtatja. Sok felhasználási esetben nincs szükség semmi továbbira. Azonban például, ha egy Swift 2.3-as projektet épít az Xcode 8.x használatával, az alapértelmezett swift megadásának egyik megközelítése a carthage bootstrap-hez a következő parancs használata:

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

    Carthage

    Carthage-t használó projekt futtatása

    A miután elvégezte a fenti lépéseket és elküldte a módosításait, a projekt többi felhasználójának csak le kell hívnia a tárolót és futtatni a carthage bootstrap-et, hogy az Ön által hozzáadott keretrendszerekkel kezdhessen.

    Keretrendszerek hozzáadása egységtesztekhez vagy egy keretrendszerhez

    A Karthago használata bármely tetszőleges célpont függőségeihez meglehetősen hasonló a Karthago alkalmazás használatához. A fő különbség abban rejlik, hogyan történik a keretrendszerek tényleges beállítása és összekapcsolása az Xcode-ban.

    Mivel az egységteszt-célpontok Általános beállítások lapjáról hiányzik a Kapcsolódó keretrendszerek és könyvtárak szakasz, ehelyett a felépített keretrendszereket a Binárisok összekapcsolása könyvtárakkal építési fázisba kell húzni.

    A tesztcélpontban a Build Settings (Építési beállítások) lapon a Runpath Search Paths (Futtatási útvonal keresési útvonalak) részhez adja hozzá a @loader_path/Frameworks-t, ha az még nincs jelen.

    Ritkán előfordulhat, hogy az egyes függőségeket is be kell másolni a build termékbe (Pl, a függőségek beágyazásához a külső keretrendszerbe, vagy annak biztosítására, hogy a függőségek jelen legyenek egy tesztcsomagban). Ehhez hozzon létre egy új Fájlok másolása építési fázist a Frameworks célállomással, majd adja hozzá a keretrendszerre való hivatkozást is. A carthage copy-frameworks parancsot nem érdemes használni, mivel a tesztkötegeknek nincs szükségük a keretrendszerek lecsupaszítására, és a copy-frameworks párhuzamos példányainak futtatása (bekapcsolt párhuzamos építéssel) nem támogatott.

    Keretrendszerek frissítése

    Ha módosította a Cartfile-t, vagy az egyes keretrendszerek legújabb verzióira szeretne frissíteni (a megadott követelmények függvényében), egyszerűen futtassa újra a carthage update parancsot.

    Ha csak egy vagy bizonyos függőségeket szeretne frissíteni, adja át őket szóközzel elválasztott listaként a update parancsnak. pl. 

    carthage update Box

    vagy

    carthage update Box Result
    Kísérleti feloldó

    A keretrendszerek frissítésének logikáját a sebesség növelése és a memóriahasználat csökkentése érdekében átírtuk. Jelenleg ez egy opt-in funkció. Használható a --new-resolver átadásával a frissítési parancshoz, pl. 

    carthage update --new-resolver Box

    Ha teljesítményproblémákat tapasztal a frissítések során, próbálja ki az új reszolvert

    Beágyazott függőségek

    Ha a projektjéhez hozzáadni kívánt keretrendszer függőségei explicit módon szerepelnek egy Cartfile-ban, a Karthago automatikusan lekérdezi azokat Ön helyett. Ezután magának kell behúznia őket a projektjébe a Carthage/Build mappából.

    Ha a projektjébe beágyazott keretrendszer más keretrendszerek függőségével rendelkezik, akkor azokat az alkalmazáscélhoz kell kapcsolnia (még akkor is, ha az alkalmazáscélnak nincs függősége az adott keretrendszerekhez, és soha nem használja azokat).

    Almodulok használata függőségekhez

    Alapértelmezés szerint a Carthage közvetlenül a függőségek forrásfájljait ellenőrzi ki a projekt mappájába, meghagyva Önnek, hogy tetszése szerint commitolja vagy figyelmen kívül hagyja őket. Ha szeretné, hogy a függőségek ehelyett Git almodulokként legyenek elérhetők (például azért, hogy a bennük lévő változásokat átruházhassa és betölthesse), akkor a carthage update vagy carthage checkout parancsot a --use-submodules flaggel futtathatja.

    Az ilyen módon futtatva a Carthage a repository .gitmodules és .git/config fájljaiba ír, és automatikusan frissíti az almodulokat, amikor a függőségek verziója megváltozik.

    A függőségek automatikus újraépítése

    Ha a fejlesztés során a függőségeken akarsz dolgozni, és azt szeretnéd, hogy a szülőprojekt építésekor automatikusan újraépüljenek, akkor hozzáadhatsz egy Run Script build fázist, amely a következőképpen hívja meg a Karthágót:

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

    Megjegyezzük, hogy ezt megelőzően almodulokat kell használnod, mert a sima ellenőrzőket nem szabad közvetlenül módosítani.

    Caching builds

    A Carthage alapértelmezés szerint újraépíti a függőséget, függetlenül attól, hogy az ugyanaz a feloldott verzió-e, mint korábban. A --cache-builds átadása arra készteti a Karthago-t, hogy elkerülje a függőség újraépítését, ha teheti. Lásd a verziófájlokról szóló információkat a részletekért, hogy a Carthage hogyan hajtja végre ezt a gyorsítótárazást.

    Megjegyzés: Jelenleg a --cache-builds nem kompatibilis a --use-submodules-vel. Mindkettő használata azt eredményezi, hogy a munkamásolat és az almodul függőségének átadott módosításai nem lesznek helyesen újraépítve. A részleteket lásd a #1785-ben.

    Bash/Zsh/Fish kiegészítés

    A Carthage parancsok és opciók automatikus kiegészítése a Bash/Zsh/Fish kiegészítésben dokumentáltak szerint érhető el.

    A Carthage támogatása a keretrendszeredhez

    A Carthage hivatalosan csak a dinamikus keretrendszereket támogatja. A dinamikus keretrendszerek az OS X bármelyik verzióján használhatók, de csak az iOS 8 vagy újabb verziókon. Ezenkívül a 0.30.0 verzió óta a Carthage támogatja a statikus keretrendszereket.

    Mivel a Carthage-nak nincs központi csomaglistája és nincs projekt specifikációs formátuma, a legtöbb keretrendszernek automatikusan kell épülnie.

    A keretrendszerek projektjének konkrét követelményei az alábbiakban vannak felsorolva.

    Xcode sémáinak megosztása

    A Carthage csak olyan Xcode sémákat épít, amelyeket megosztott a .xcodeproj-ból. A carthage build --no-skip-current futtatásával, majd a Carthage/Build mappa ellenőrzésével láthatja, hogy az összes tervezett séma sikeresen épül-e.

    Ha egy fontos séma nem épül meg, amikor ezt a parancsot futtatja, nyissa meg az Xcode-ot, és győződjön meg róla, hogy a séma meg van jelölve megosztottként, így a Carthage fel tudja fedezni.

    Építési hibák megoldása

    Ha a carthage build --no-skip-current-ben építési hibákat tapasztal, próbálja meg futtatni a xcodebuild -scheme SCHEME -workspace WORKSPACE build vagy a xcodebuild -scheme SCHEME -project PROJECT build parancsot (a tényleges értékekkel), és nézze meg, hogy ott is előfordul-e ugyanaz a hiba. Ez remélhetőleg elegendő információt ad a probléma megoldásához.

    Ha az Apple fejlesztői eszközeinek több verziója van telepítve (például egy Xcode béta verzió), a xcode-select segítségével megváltoztathatja, hogy a Carthage melyik verziót használja.

    Ha még mindig nem tudja a keretrendszerét a Carthage segítségével építeni, kérjük, nyisson egy problémát, és szívesen segítünk!

    Stabil kiadások címkék

    A Carthage úgy határozza meg, hogy a keretrendszerének mely verziói állnak rendelkezésre, hogy átnézi az adattárban közzétett címkéket, és megpróbálja az egyes címkék nevét szemantikus verzióként értelmezni. Például a v1.2 címkében a szemantikus verzió az 1.2.0.

    Tagek verziószám nélkül, vagy a verziószámot követő bármilyen karakterrel (pl., 1.2-alpha-1) jelenleg nem támogatottak, és figyelmen kívül maradnak.

    Előre elkészített keretrendszerek archiválása egy zip-fájlba

    A Karthage képes automatikusan használni az előre elkészített keretrendszereket, ahelyett, hogy a semmiből építene, ha azok egy GitHub Release-hez vannak csatolva a projekt tárolóján vagy egy bináris projektdefiníciós fájlon keresztül.

    Az előre elkészített keretrendszerek felajánlásához egy adott címkéhez az összes támogatott platform binárisát egy archívumba kell összezsuppolni, és ezt az archívumot egy közzétett, az adott címkének megfelelő Release-hez kell csatolni. A csatolmánynak tartalmaznia kell a .framework-t a nevében (pl. ReactiveCocoa.framework.zip), hogy jelezze a Karthago számára, hogy binárisokat tartalmaz. Az archívum könyvtárszerkezete szabad, de a keretrendszerek csak egyszer jelenhetnek meg az archívumban, mivel a nevük alapján a Carthage/Build/<platform>-be lesznek másolva (pl. ReactiveCocoa.framework).

    Az archiválási műveletet magával a Karthago segítségével is elvégezheti:

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

    vagy alternatívaként

    carthage build --archive

    A kiadványtervezetek automatikusan figyelmen kívül maradnak, még akkor is, ha megfelelnek a kívánt címkének.

    Használja a travis-ci-t a címkével ellátott előre elkészített keretrendszerek feltöltéséhez

    Megoldható a travis-ci használata a címkével ellátott kiadások elkészítéséhez és feltöltéséhez.

    1. Telepítse a travis CLI-t a gem install travis

    2. Telepítse a travis-ci-t az adattárához (1. és 2. lépés)

    3. Ez alapján hozzon létre .travis.yml fájlt az adattár gyökerében. Állítsa FRAMEWORK_NAME a megfelelő értékre.

      A PROJECT_PLACEHOLDER és SCHEME_PLACEHOLDER

      Ha projekt helyett munkaterületet használ, távolítsa el az xcode_project sort, és vegye ki a megjegyzést az xcode_workspace sorból.

      A projektnek a következő formátumúnak kell lennie: MyProject.xcodeproj

      A munkaterületnek a következő formátumban kell lennie: MyProject.xcodeproj

      A munkaterületnek a következő formátumban kell lennie: MyProject.xcodeproj

      A munkaterületnek a következő formátumban kell lennie: MyWorkspace.xcworkspace

      A xcode_sdk értéket nyugodtan frissítheti egy másik SDK-ra, vegye figyelembe, hogy az iphoneos SDK-n való teszteléshez kódaláíró azonosítót kellene feltöltenie

      További információkért látogasson el a 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. Futtassa travis setup releases, kövesse a dokumentációt itt

      Ez a parancs kódolja a GitHub hitelesítő adatait a .travis.yml fájlba, hogy a travis feltölthesse a kiadást a GitHub-ra.comAmikor megkérdezi a feltölteni kívánt fájlt, írja be a $FRAMEWORK_NAME.framework.zip

    5. A deploy szakasz frissítése a címkék futtatásához:

      A .travis.yml-ban keresse meg:

      on: repo: repo/repo

      És adja hozzá a tags: true és skip_cleanup: true fájlokat:

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

      Ez tudatja a travis-szal, hogy egy új tag elküldésekor létrehozzon egy telepítést, és megakadályozza, hogy a travis megtisztítsa a generált zip fájlt

    Statikus keretrendszerek építése az alkalmazás indítási idejének felgyorsításához

    Ha sok dinamikus keretrendszert ágyazol be az alkalmazásodba, a fő indítás előtti indítási ideje meglehetősen lassú lehet. A Karthago képes segíteni ennek enyhítésében azzal, hogy a dinamikus keretrendszereket statikus keretrendszerekként építi fel helyette. A statikus keretrendszerek néhány egyszerű módosítással közvetlenül az alkalmazásba linkelhetők, vagy egy nagyobb dinamikus keretrendszerbe olvaszthatók össze a munkafolyamatok néhány egyszerű módosításával, ami drámai csökkenést eredményezhet a főindítás előtti indítási időkben.

    Carthage 0.30.0 vagy újabb

    A 0.30.0 verzió óta a Carthage projekt támogatja a Swift vagy Objective-C nyelven írt statikusan linkelt keretrendszereket, amelyek támogatása az Xcode 9.4-ben került bevezetésre. Felhívjuk azonban a figyelmet arra, hogy kifejezetten keretrendszerekről van szó, ezért a Darwin csomagok .framework kiterjesztéssel és statikusan linkelt objektumarchívumokkal vannak benne. A Karthago jelenleg nem támogatja a statikus könyvtári sémákat, és a jövőben sem tervezik a támogatásuk bevezetését.

    A munkafolyamat alig különbözik:

    • Még mindig be kell jelölnie a Karthago-kompatibilis projektjének megosztott sémáit a Termék > Séma > Sémák kezelése… alatt, ugyanúgy, mint a dinamikus binárisok esetében
    • Még mindig statikus .keretrendszerek ellen a projekted Build fázisaiban ugyanúgy, mint a dinamikus binárisoknál

    Mégis:

    • A Carthage-kompatibilis projekted Cocoa Framework targetjének Build Settings, Linking szakaszában állítsd a Mach-O Type-ot Static Library-ra
    • A statikusan linkelt keretrendszerek a ./Carthage/Build/$(PLATFORM_NAME)/Static
    • Nem szabad a statikus keretrendszereket input/output fájlként hozzáadni a carthage copy-frameworks Build Phase

    Carthage 0.29.0 vagy alacsonyabb

    A részletekért lásd a StaticFrameworks doc-ot.

    Kérlek vedd figyelembe, hogy néhány fenntartás vonatkozik erre a megközelítésre:

    • A statikus keretrendszereket az Apple hivatalosan nem támogatja
    • Ez egy fejlett munkafolyamat, amely nincs beépítve a Carthage-be, YMMV

    Deklaráld a kompatibilitást

    Hirdetni szeretnéd, hogy a projekted használható a Carthage-el? Hozzáadhatsz egy kompatibilitási jelvényt:

    … a README-hez, egyszerűen a következő Markdown beillesztésével:

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

    Ismert problémák

    DWARFs symbol problem

    Az előre megépített keretrendszer nem hibakereshető step execution segítségével más gépen, mint amelyen a keretrendszer épült. Egyszerűen carthage bootstrap/build/update --no-use-binaries ezt meg kell oldania, de az automatizáltabb megoldásért lásd a #924-et. Dupe rdar://23551273, ha azt szeretné, hogy az Apple javítsa a probléma gyökerét.

    CarthageKit

    A carthage parancssori eszköz legtöbb funkciója valójában egy CarthageKit nevű keretrendszerbe van kapszulázva.

    Ha szeretnéd a Carthage-ot egy másik eszköz részeként használni, vagy esetleg bővíteni a Carthage funkcionalitását, vess egy pillantást a CarthageKit forráskódjára, hogy megnézd, az API megfelel-e az igényeidnek.

    A Carthage és a CocoaPods közötti különbségek

    A CocoaPods egy régóta létező függőségkezelő a Cocoa számára. Akkor miért jött létre a Carthage?

    Először is, a CocoaPods (alapértelmezés szerint) automatikusan létrehoz és frissít egy Xcode munkaterületet az alkalmazásodnak és az összes függőségnek. A Carthage a xcodebuild keretrendszer binárisokat építi xcodebuild, de az integrálás felelősségét a felhasználóra bízza. A CocoaPods megközelítése könnyebben használható, míg a Carthage rugalmas és nem tolakodó.

    A CocoaPods célja a README-ben így szerepel:

    … a harmadik féltől származó nyílt forráskódú könyvtárak felfedezhetőségének és az azokba való bekapcsolódásnak a javítása egy központosított ökoszisztéma létrehozásával.

    A Carthage ezzel szemben decentralizált függőségkezelőként jött létre. Nincs központi lista a projektekről, ami csökkenti a karbantartási munkát és elkerüli a központi hibapontokat. A projektek felkutatása azonban nehezebb – a felhasználóknak a GitHub Trending oldalaihoz vagy hasonlóhoz kell folyamodniuk.

    A CocoaPods projekteknek rendelkezniük kell egy úgynevezett podspec fájlal is, amely metaadatokat tartalmaz a projektről, és meghatározza, hogyan kell építeni. A Carthage xcodebuild a függőségek építésére használja, ahelyett, hogy egyetlen munkaterületbe integrálná őket, nincs hasonló specifikációs fájlja, de a függőségeknek saját Xcode-projektet kell tartalmazniuk, amely leírja, hogyan kell építeni a termékeiket.

    Végeredményben azért hoztuk létre a Carthage-ot, mert a lehető legegyszerűbb eszközt akartuk – egy függőségkezelőt, amely elvégzi a munkát anélkül, hogy átvenné az Xcode felelősségét, és anélkül, hogy extra munkát okozna a keretrendszerek szerzőinek. A CocoaPods számos olyan csodálatos funkciót kínál, amelyekkel a Carthage soha nem fog rendelkezni, a további bonyolultság rovására.

    Licenc

    A Carthage a MIT licenc alatt jelenik meg.

    A címlapfotó a CC BY-NC-SA 2.0 licenc alatt jelenik meg. Az eredeti fotót Richard Mortel készítette.

Similar Posts

Vélemény, hozzászólás?

Az e-mail-címet nem tesszük közzé.