Xcode „Build and Archive” z wiersza poleceń

Xcode 3.2 zapewnia nową, niesamowitą funkcję w menu kompilacji „Kompiluj i archiwizuj”, która generuje plik .ipa odpowiedni do dystrybucji Ad Hoc. Możesz także otworzyć Organizatora, przejść do „Zarchiwizowanych aplikacji” i „Prześlij aplikację do iTunesConnect”.

Czy istnieje sposób użycia „Kompilacji i archiwizacji” z wiersza poleceń (jako część skryptu kompilacji)? Zakładam, że xcodebuildbyłby to w jakiś sposób zaangażowane, ale manstrona wydaje się nic na ten temat nie mówić.

AKTUALIZACJA Michael Grinich poprosił o wyjaśnienia; oto, czego dokładnie nie możesz zrobić z kompilacjami z wiersza poleceń, funkcje, które możesz zrobić TYLKO z Xcode's Organizer po „Kompilacji i archiwizacji”.

1. Możesz kliknąć „Udostępnij aplikację ...”, aby udostępnić IPA testerom wersji beta. Jak zauważa Guillaume poniżej, z powodu pewnej magii Xcode, ten plik IPA nie wymaga osobnego pliku .mobileprovision, który muszą zainstalować beta-testerzy; to magiczne. Żaden skrypt wiersza poleceń nie może tego zrobić. Na przykład skrypt Arrix (przesłany 1 maja) nie spełnia tego wymogu.
2. Co ważniejsze, po przetestowaniu kompilacji w wersji beta możesz kliknąć „Prześlij aplikację do iTunes Connect”, aby przesłać tę DOKŁADNĄ tę samą kompilację do Apple, bardzo przetestowanej wersji binarnej, bez jej odbudowywania. Jest to niemożliwe z wiersza poleceń, ponieważ podpisywanie aplikacji jest częścią procesu kompilacji; możesz podpisać bity do testów beta Ad Hoc LUB możesz je podpisać w celu przesłania do App Store, ale nie jedno i drugie. Żaden IPA zbudowany w wierszu polecenia nie może być testowany w wersji beta na telefonach, a następnie przesyłany bezpośrednio do Apple.

Chciałbym, aby ktoś przyszedł i udowodnił, że się mylę: obie te funkcje działają świetnie w graficznym interfejsie użytkownika Xcode i nie można ich replikować z wiersza poleceń.

Odkryłem, jak zautomatyzować proces kompilacji i archiwizacji z linii poleceń, właśnie napisałem artykuł na blogu wyjaśniający, jak możesz to osiągnąć.

Polecenie, którego musisz użyć, to xcrun:

/usr/bin/xcrun -sdk iphoneos PackageApplication \
-v "${RELEASE_BUILDDIR}/${APPLICATION_NAME}.app" \
-o "${BUILD_HISTORY_DIR}/${APPLICATION_NAME}.ipa" \
--sign "${DEVELOPER_NAME}" \
--embed "${PROVISONING_PROFILE}"

Wszystkie szczegóły znajdziesz w tym artykule . Jeśli masz jakieś pytania, nie wahaj się zadać.

W Xcode 4.2 możesz użyć flagi -scheme, aby to zrobić:

xcodebuild -scheme <SchemeName> archive

Po tym poleceniu Archiwum pojawi się w Xcode Organizer.

Aktualizacja mojej odpowiedzi za pomocą Xcode 9 i Swift

Archiwum

xcodebuild -workspace <ProjectName>/<ProjectName>.xcworkspace \
  -scheme <schemeName> clean archive -configuration release \
  -sdk iphoneos -archivePath <ProjectName>.xcarchive

Eksport IPA ( zwróć uwagę na listę opcji eksportu )

xcodebuild -exportArchive -archivePath  <ProjectName>.xcarchive \
  -exportOptionsPlist  <ProjectName>/exportOptions.plist \
  -exportPath  <ProjectName>.ipa

Dla tych, którzy nie wiedzą o exportOptions.plist, https://blog.bitrise.io/new-export-options-plist-in-xcode-9

Ci, którzy używali tego do budowy projektu w narzędziach CI / CD, takich jak teamcity / jenkins, upewnij się, że używasz odpowiedniego xcode zainstalowanego w agencie kompilacji do archiwizacji i eksportu.

Możesz użyć do tego jednej z 2 poniższych opcji.

1. Użyj pełnej ścieżki do xcodebuild,

/Applications/Xcode 9.3.1.app/Contents/Developer/usr/bin/xcodebuild

2. Użyj xcode-select,

xcode-select -switch /Applications/Xcode 9.3.1.app

Poniżej moja stara odpowiedź

Oto skrypt wiersza poleceń do tworzenia archiwum i przykładu IPA. Mam projekt iPhone'a xcode, który znajduje się w folderze Desktop / MyiOSApp.

Wykonaj następujące polecenia jeden po drugim:

cd /Users/username/Desktop/MyiOSApp/

xcodebuild -scheme MyiOSApp archive \
  -archivePath /Users/username/Desktop/MyiOSApp.xcarchive

xcodebuild -exportArchive -exportFormat ipa \
  -archivePath "/Users/username/Desktop/MyiOSApp.xcarchive" \
  -exportPath "/Users/username/Desktop/MyiOSApp.ipa" \
  -exportProvisioningProfile "MyCompany Distribution Profile"

Jest to testowane z Xcode 5 i działa dobrze dla mnie.

Używam własnego skryptu kompilacji do generowania pakietu IPA do dystrybucji ad hoc.

die() {
    echo "$*" >&2
    exit 1
}

appname='AppName'
config='Ad Hoc Distribution'
sdk='iphoneos3.1.3'
project_dir=$(pwd)

echo using configuration $config

echo updating version number
agvtool bump -all
fullversion="$(agvtool mvers -terse1)($(agvtool vers -terse))"
echo building version $fullversion

xcodebuild -activetarget -configuration "$config" -sdk $sdk build || die "build failed"

echo making ipa...
# packaging
cd build/"$config"-iphoneos || die "no such directory"
rm -rf Payload
rm -f "$appname".*.ipa
mkdir Payload
cp -Rp "$appname.app" Payload/
if [ -f "$project_dir"/iTunesArtwork ] ; then
    cp -f "$project_dir"/iTunesArtwork Payload/iTunesArtwork
fi

ipaname="$appname.$fullversion.$(date -u +%Y%m%d%H%M%S).ipa"
zip -r $ipaname Payload

echo finished making $ipaname

Skrypt zwiększa także numer wersji. Możesz usunąć tę część, jeśli nie jest potrzebna. Mam nadzieję, że to pomoże.

xcodebuildNarzędzie może zbudować i archiwum eksport produktów z -exportArchive flagi (jak z Xcode 5). Krok eksportu był wcześniej możliwy tylko za pośrednictwem interfejsu użytkownika Xcode Organizer.

Najpierw zarchiwizuj aplikację:

xcodebuild -scheme <scheme name> archive

Biorąc pod uwagę $ARCHIVE_PATH(ścieżka do .xcarchive pliku ), wyeksportuj aplikację z archiwum za pomocą jednego z poniższych:

Plik .ipa dla systemu iOS :

xcodebuild -exportArchive -exportFormat ipa -archivePath "$ARCHIVE_PATH" -exportPath "myApp.ipa" -exportProvisioningProfile "My App Provisioning profile"

Plik .app systemu Mac :

xcodebuild -exportArchive -exportFormat app -archivePath "$ARCHIVE_PATH" -exportPath "myApp.app" -exportSigningIdentity "Developer ID Application: My Software Company"

W obu komendach argumenty -exportProvisioningProfile i -exportSigningIdentity są opcjonalne. man xcodebuildpo szczegóły dotyczące semantyki. W tych przykładach profil udostępniania dla kompilacji iOS określa profil udostępniania dystrybucji AdHoc, a tożsamość podpisująca dla aplikacji Mac określa ID programisty do eksportu jako aplikacja innej firmy (tj. Nie dystrybuowana za pośrednictwem Mac App Store).

Opracowaliśmy aplikację na iPada z XCode 4.2.1 i chcieliśmy zintegrować tę wersję z naszą ciągłą integracją (Jenkins) w celu dystrybucji OTA. Oto rozwiązanie, które wymyśliłem:

# Unlock keychain
security unlock-keychain -p jenkins /Users/jenkins/Library/Keychains/login.keychain

# Build and sign app
xcodebuild -configuration Distribution clean build

# Set variables
APP_PATH="$PWD/build/Distribution-iphoneos/iPadApp.app"
VERSION=`defaults read $APP_PATH/Info CFBundleShortVersionString`
REVISION=`defaults read $APP_PATH/Info CFBundleVersion`
DATE=`date +"%Y%m%d-%H%M%S"`
ITUNES_LINK="<a href=\"itms-services:\/\/?action=download-manifest\&url=https:\/\/xxx.xxx.xxx\/iPadApp-$VERSION.$REVISION-$DATE.plist\">Download iPad2-App v$VERSION.$REVISION-$DATE<\/a>"

# Package and verify app
xcrun -sdk iphoneos PackageApplication -v build/Distribution-iphoneos/iPadApp.app -o $PWD/iPadApp-$VERSION.$REVISION-$DATE.ipa

# Create plist
cat iPadApp.plist.template | sed -e "s/\${VERSION}/$VERSION/" -e "s/\${DATE}/$DATE/" -e "s/\${REVISION}/$REVISION/" > iPadApp-$VERSION.$REVISION-$DATE.plist

# Update index.html
curl https://xxx.xxx.xxx/index.html -o index.html.$DATE
cat index.html.$DATE | sed -n '1h;1!H;${;g;s/\(<h3>Aktuelle Version<\/h3>\)\(.*\)\(<h3>&Auml;ltere Versionen<\/h3>.<ul>.<li>\)/\1\
${ITUNES_LINK}\
\3\2<\/li>\
<li>/g;p;}' | sed -e "s/\${ITUNES_LINK}/$ITUNES_LINK/" > index.html

Następnie Jenkins przesyła pliki IPA, Plist i HTML do naszego serwera.

To jest szablon plist:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>items</key>
    <array>
        <dict>
            <key>assets</key>
            <array>
                <dict>
                    <key>kind</key>
                    <string>software-package</string>
                    <key>url</key>
                    <string>https://xxx.xxx.xxx/iPadApp-${VERSION}.${REVISION}-${DATE}.ipa</string>
                </dict>
                <dict>
                    <key>kind</key>
                    <string>full-size-image</string>
                    <key>needs-shine</key>
                    <true/>
                    <key>url</key>
                    <string>https://xxx.xxx.xxx/iPadApp.png</string>
                </dict>
                <dict>
                    <key>kind</key>
                    <string>display-image</string>
                    <key>needs-shine</key>
                    <true/>
                    <key>url</key>
                    <string>https://xxx.xxx.xxx/iPadApp_sm.png</string>
                </dict>
            </array>
            <key>metadata</key>
            <dict>
                <key>bundle-identifier</key>
                <string>xxx.xxx.xxx.iPadApp</string>
                <key>bundle-version</key>
                <string>${VERSION}</string>
                <key>kind</key>
                <string>software</string>
                <key>subtitle</key>
                <string>iPad2-App</string>
                <key>title</key>
                <string>iPadApp</string>
            </dict>
        </dict>
    </array>
</dict>
</plist>

Aby to skonfigurować, musisz zaimportować certyfikat dystrybucyjny i profil informacyjny do pęku kluczy wyznaczonego użytkownika.

Trudno mi było znaleźć inne odpowiedzi tutaj. Ten artykuł zrobił, jeśli dla mnie. Niektóre ścieżki mogą wymagać absolutności, jak wspomniano w innych odpowiedziach.

Komenda:

xcrun -sdk iphoneos PackageApplication \
    "/path/to/build/MyApp.app" \
    -o "output/path/to/MyApp.ipa" \
    --sign "iPhone Distribution: My Company" \
    --embed "/path/to/something.mobileprovision"

Możesz zrezygnować z kompilacji, tak jak robi to XCode, abyś mógł przetestować i wysłać ten sam plik binarny. Na przykład w moim skrypcie (podobnym do powyższego) buduję moją wersję wydania podpisaną jako kompilacja AdHoc, następnie archiwizuję ją jako IPA do testowania, następnie rezygnuję z certyfikatu dystrybucyjnego i tworzę plik zip, do którego wysyłam Jabłko. Odpowiednia linia to:

codesign -f -vv -s "$DistributionIdentity" "$APPDIR"

W przypadku Xcode 7 masz znacznie prostsze rozwiązanie. Jedyną dodatkową pracą jest to, że musisz utworzyć plik listy konfiguracji do eksportu archiwum.

(W stosunku do Xcode 6, w wyniku xcrun xcodebuild -help, -exportFormata -exportProvisioningProfileopcje nie są wspomniane już więcej, a pierwsza jest usuwana, a ten ostatni jest zastąpiona-exportOptionsPlist ).

Krok 1 , zmień katalog na folder zawierający plik .xcodeproject lub .xcworkspace.

cd MyProjectFolder

Krok 2 , użyj Xcode lub, /usr/libexec/PlistBuddy exportOptions.plistaby utworzyć plik listy opcji eksportu. Przy okazji xcrun xcodebuild -helppowie ci, jakie klucze musisz wstawić do pliku Plist.

Krok 3 , utwórz plik .xcarchive (w rzeczywistości folder) w następujący sposób (katalog build / zostanie teraz automatycznie utworzony przez Xcode),

xcrun xcodebuild -scheme MyApp -configuration Release archive -archivePath build/MyApp.xcarchive

Krok 4 , wyeksportuj jako plik .ipa w ten sposób, który różni się od Xcode6

xcrun xcodebuild -exportArchive -exportPath build/ -archivePath build/MyApp.xcarchive/ -exportOptionsPlist exportOptions.plist

Teraz masz plik IPA w katalogu build /. Wystarczy wysłać go do Apple App Store.

Nawiasem mówiąc, plik ipa utworzony przez Xcode 7 jest znacznie większy niż przez Xcode 6.

Podałem krótki opis kroków, które należy wykonać, oraz parametrów, które należy przekazać podczas generowania IPA przy użyciu terrminal poniżej:

1. Przejdź do folderu zawierającego plik MyApp.xcodeproject w terminalu

2. Za pomocą polecenia podanego poniżej uzyskasz wszystkie cele aplikacji

   /usr/bin/xcodebuild -list 

3. Po wykonaniu powyższej komendy otrzymasz listę celów, z których powinieneś wybrać konkretny cel, który chcesz wygenerować .ipa

   /usr/bin/xcodebuild -target $TARGET -sdk iphoneos -configuration Release

4. Powyższe polecenie buduje projekt i tworzy plik .app. Ścieżką do zlokalizowania pliku .app jest ./build/Release-iphoneos/MyApp.app

5. Po pomyślnym zakończeniu kompilacji wykonaj następującą komendę, aby wygenerować .ipa aplikacji przy użyciu nazwy programisty i profilu administracyjnego, używając poniższej składni:

   /usr/bin/xcrun -sdk iphoneos PackageApplication -v “${TARGET}.app” -o “${OUTDIR}/${TARGET}.ipa” –sign “${IDENTITY}” –embed “${PROVISONING_PROFILE}”

Objaśnienie każdego parametru w powyższej składni:

${TARGET}.app                == Target path (ex :/Users/XXXXXX/desktop/Application/build/Release-iphoneos/MyApp.app)
${OUTDIR}                    == Select the output directory(Where you want to save .ipa file)
${IDENTITY}                   == iPhone Developer: XXXXXXX (XXXXXXXXXX)(which can be obtained from Keychain access)
${PROVISONING_PROFILE}   == Path to the provisioning profile(/Users/XXXXXX/Library/MobileDevice/Provisioning Profiles/XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX.mobileprovision”)

6. ipa zostanie wygenerowany w wybranym katalogu wyjściowym „ $ {OUTDIR} ”

Xcode 8:

Format IPA:

xcodebuild -exportArchive -exportFormat IPA -archivePath MyMobileApp.xcarchive -exportPath MyMobileApp.ipa -exportProvisioningProfile 'MyMobileApp Distribution Profile'

Eksportuje archiwum MyMobileApp.xcarchive jako plik IPA do ścieżki MyMobileApp.ipa przy użyciu profilu udostępniania MyMobileApp Distribution Profile.

Format aplikacji:

xcodebuild -exportArchive -exportFormat APP -archivePath MyMacApp.xcarchive -exportPath MyMacApp.pkg -exportSigningIdentity 'Developer ID Application: My Team'

Eksportuje archiwum MyMacApp.xcarchive jako plik PKG do ścieżki MyMacApp.pkg przy użyciu aplikacji kation tożsamości tożsamości podpisującej kation ID programisty Aplikacja: Mój zespół. Tożsamość podpisująca instalatora Identyfikator programisty Instalator: Mój zespół jest domyślnie używany do podpisania eksportowanego pakietu.

Strona podręcznika użytkownika Xcodebuild

Przejdź do folderu, w którym znajduje się katalog główny projektu i:

xcodebuild -project projectname -activetarget -activeconfiguration archive

Idąc o krok dalej, przesyłanie do iTunesConnect za pomocą wiersza poleceń za pomocą Xcode 7 ! (Zakładając, że zaczynasz od.ipa od podpisanego przy użyciu prawidłowego profilu wydania i tożsamości podpisu).

Wprowadź altoolinterfejs CLI dla modułu ładującego aplikacje ( docs, strona 38). Ukryta głęboko w strukturze Xcode.app, jest przydatna funkcja, która pozwala nam przesyłać bezpośrednio do ItunesConnect.

/Applications/Xcode.app/Contents/Applications/Application Loader.app/Contents/Frameworks/ITunesSoftwareService.framework/Versions/A/Support/altool

Po prostu biegnij, $ altool --upload-app -f file -u username [-p password]aby przesłać swoją świeżo wybitą.ipa prosto do Apple. Hasło jest opcjonalne i poprosi o podanie go, jeśli nie podasz tego polecenia.

Jeśli podczas weryfikacji wystąpią problemy z aplikacją, konsola je wydrukuje.

Prawdopodobnie będziesz musiał wyeksportować ścieżkę, altooljeśli nie chcesz zapisać jej lokalizacji.

export PATH=$PATH:/Applications/Xcode.app/Contents/Applications/Application\ Loader.app/Contents/Frameworks/ITunesSoftwareService.framework/Versions/A/Support/

Otóż ​​to! Po prostu zaloguj się na iTunesConnect.com i wybierz nową wersję do testowania za pomocą testflight.

Uwaga końcowa: Jeśli pojawi się komunikat o błędzie Exception while launching iTunesTransporter: Transporter not found at path: /usr/local/itms/bin/iTMSTransporter. You should reinstall the application, możesz postępować zgodnie z sugestią zawartą w tej odpowiedzi SO , aby uruchomić dowiązanie symboliczne do właściwej lokalizacji:

ln -s /Applications/Xcode.app/Contents/Applications/Application\ Loader.app/Contents/itms /usr/local/itms

Poprawiając odpowiedź Vincenta, napisałem skrypt, aby to zrobić: xcodearchive
Pozwala ci zarchiwizować (wygenerować IPA) swój projekt za pomocą wiersza poleceń. Pomyśl o tym jak o siostrze xcodebuilddowodzenia, ale o archiwizację.

Kod jest dostępny na github: http://github.com/gcerquant/xcodearchive

Jedną z opcji skryptu jest włączenie archiwizacji symboli dSYM w archiwum ze znacznikiem czasu. Nie ma usprawiedliwienia, aby nie przechowywać symboli i nie być w stanie symbolizować dziennika awarii, który możesz później otrzymać.

Jak zbudować projekt iOS za pomocą polecenia?

Clean : codebuild clean -workspace work-space-name.xcworkspace -scheme scheme-name 

I &

Archive : xcodebuild archive -workspace work-space-name.xcworkspace -scheme "scheme-name" -configuration Release -archivePath IPA-name.xcarchive 

I &

Export : xcodebuild -exportArchive -archivePath IPA-name.xcarchive -exportPath IPA-name.ipa -exportOptionsPlist exportOptions.plist

Co to jest ExportOptions.plist?

ExportOptions.plist jest wymagany w Xcode. Pozwala określić niektóre opcje podczas tworzenia pliku IPA. Możesz wybrać opcje w przyjaznym interfejsie użytkownika podczas korzystania z Xcode do archiwizowania aplikacji.

Ważne : Metoda wydania i rozwoju różni się w ExportOptions.plist

AppStore:

exportOptions_release ~ method = app-store

Rozwój

exportOptions_dev ~ method = development

wypróbuj xctool, jest to zamiennik xcodebuild firmy Apple, który ułatwia budowanie i testowanie produktów iOS i Mac. Jest to szczególnie pomocne w przypadku ciągłej integracji. Ma kilka dodatkowych funkcji:

1. Uruchamia te same testy, co Xcode.app.
2. Ustrukturyzowana wydajność wyników kompilacji i testów.
3. Przyjazny dla człowieka wydruk w kolorze ANSI.

Numer 3 jest niezwykle przydatny. Nie wiem, czy ktokolwiek może odczytać dane wyjściowe konsoli xcodebuild, nie mogę, zwykle dało mi to jedną linię z ponad 5000 znakami. Jeszcze trudniejszy do odczytania niż praca dyplomowa.

xctool: https://github.com/facebook/xctool

jeśli użyjesz następnego narzędzia: https://github.com/nomad/shenzhen

to zadanie jest bardzo łatwe:

which ipa 1>/dev/null 2>&1 || echo 'no shenzhen. to install use: sudo gem install shenzhen --no-ri --no-rdoc'
ipa build --verbose --scheme "${schemeName}"

źródło

Po aktualizacji do Xcode 8 okazało się, że Enterprise IPA generuje przez

/usr/bin/xcrun -sdk iphoneos PackageApplication -v "${RELEASE_BUILDDIR}/${APPLICATION_NAME}.app" -o "${BUILD_HISTORY_DIR}/${APPLICATION_NAME}.ipa" --sign "${DEVELOPER_NAME}" --embed "${PROVISONING_PROFILE}" 

Nie można uruchomić polecenia z powodu problemów z podpisami. Dziennik wskazuje, że „ostrzeżenie: PackageApplication jest przestarzałe, użyj xcodebuild -exportArchivezamiast niego.

Więc przełączam się xcodebuild -exportArchivei wszystko wróciło do normy.

Masz na myśli opcje sprawdzania poprawności / udostępniania / przesyłania? Myślę, że są one specyficzne dla Xcode i nie są odpowiednie dla narzędzia do budowania z linii poleceń.

Przy odrobinie sprytu, założę się, że możesz zrobić skrypt, który zrobi to za Ciebie. Wygląda na to, że są po prostu przechowywane ~/Library/MobileDevice/Archived Applications/z UUDI i listwą. Nie mogę sobie również wyobrazić, że tak trudno byłoby dokonać inżynierii wstecznej walidatora.

Automatyzacja procesu, który mnie interesuje, polega na wysyłaniu kompilacji do testerów wersji beta. (Ponieważ przesyłanie do App Store zdarza się rzadko, nie mam nic przeciwko robieniu tego ręcznie, zwłaszcza, że ​​często muszę dodawać nowy tekst opisu). Wykonując pseudo Budowanie + Archiwum za pomocą interfejsu CLI Xcode, mogę wyzwalać automatyczne kompilacje z każdego zatwierdzenia kodu, utwórz pliki IPA z osadzonymi profilami udostępniania i prześlij je pocztą e-mail do testerów.