Xcode "Buduj i archiwizuj" z wiersza poleceń

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 (proszę zwrócić uwagę na opcję eksportu plist )

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 budowania projektów w narzędziach CI / CD, takich jak TeamCity / jenkins, upewnij się, że używasz odpowiedniego xcode zainstalowany w build agent dla zarówno archiwum jak i eksportu.

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

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

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

1. użyj Xcode-select,

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

Poniżej stara ODPOWIEDŹ

Oto skrypt wiersza poleceń do tworzenia archiwum i przykład IPA. Mam projekt iPhone 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"

To jest testowane z Xcode 5 i działa dobrze dla mnie.

Używam własnego skryptu budowania do generowania pakietu ipa dla 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 również Numer wersji. Możesz usunąć tę część, jeśli nie jest potrzebna. Mam nadzieję, że to pomoże.

Opracowaliśmy aplikację na iPada z XCode 4.2.1 i chcieliśmy zintegrować tę kompilację z naszą ciągłą integracją (Jenkins) dla 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 wgrywa pliki ipa, plist i html na nasz serwer.

To jest szablon plista:

<?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 dystrybucji i profil aprowizacji do łańcucha kluczy wyznaczonego użytkownika.

Narzędzie xcodebuild może budować i eksportować produkty archiwalne za pomocą znacznika -exportArchive (od Xcode 5). Krok eksportu był wcześniej możliwy tylko za pośrednictwem interfejsu Organizatora Xcode.

Najpierw zarchiwizuj swoją aplikację:

xcodebuild -scheme <scheme name> archive

Given $ARCHIVE_PATH (ścieżka do .xcarchive Plik), Wyeksportuj aplikację z archiwum za pomocą jednego z poniższych:

IOS .IPA file:

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

Mac .plik app :

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

W obu komend -exportprovisioningprofile i -exportSigningIdentity argumenty są opcjonalne. man xcodebuild aby uzyskać szczegółowe informacje na temat semantyki. W tych przykładach profil aprowizacji dla kompilacji systemu iOS określał profil aprowizacji dystrybucji AdHoc, a tożsamość podpisywania dla aplikacji Mac określono identyfikator dewelopera do eksportu jako aplikacja innej firmy (tzn. nie dystrybuowana za pośrednictwem sklepu Mac App Store).

Znalazłem kilka innych odpowiedzi tutaj trudne do uzyskania. Ten artykuł zrobił jeśli dla mnie. Niektóre ścieżki muszą być bezwzględne, jak wspomniano w innych odpowiedziach.

Polecenie:

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, dzięki czemu możesz testować i wysyłać te same pliki binarne. Na przykład w moim skrypcie (podobnym do tych powyżej) buduję wersję release podpisaną jako adhoc build, następnie archiwizuję ją jako IPA do testowania, następnie rezygnuję z mojego certyfikatu dystrybucji i tworzę plik zip, który wysyłam do Apple. Odpowiedni wiersz to:

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

Dla Xcode 7 , masz znacznie prostsze rozwiązanie. Jedyną dodatkową pracą jest to, że musisz utworzyć plik plist konfiguracyjny do eksportowania archiwum.

(w porównaniu do Xcode 6, w wynikach xcrun xcodebuild -help, -exportFormat i -exportProvisioningProfile opcje nie są już wymienione; pierwsza zostaje usunięta, a druga zastąpiona przez -exportOptionsPlist.)

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

cd MyProjectFolder

Krok 2 , użyj Xcode lub /usr/libexec/PlistBuddy exportOptions.plist aby utworzyć opcje eksportu pliku plist. Przy okazji, xcrun xcodebuild -help powie Ci, jakie klucze musisz włożyć do pliku plist.

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

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

Krok 4 , Eksportuj jako .plik ipa podobny do tego, który różni się od Xcode6

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

Teraz dostajesz plik ipa w katalogu build/. Wystarczy wysłać go do apple App Store.

Przy okazji, plik ipa stworzony 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 za pomocą terrminal poniżej:

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

2. Używając poniższego polecenia otrzymasz wszystkie cele aplikacji

   /usr/bin/xcodebuild -list 
   

3. Po wykonaniu powyższego polecenia 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 aplikacji.Ścieżka do zlokalizowania .plik aplikacji jest ./build/Release-iphoneos/MyApp.app

5. Po pomyślnym zbudowaniu wykonaj następujące polecenie do wygenerowania .ipa aplikacji używającej nazwy dewelopera i profilu Aprowizacji przy użyciu poniższej składni:

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

Wyjaś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”)

1. 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 za pomocą provisioning profile 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 za pomocą aplikacji appli-cation cation signing identity Developer id Application: mój zespół. Na tożsamość podpisu instalatora Instalator ID dewelopera: mój zespół jest domyślnie używany do podpisywania eksportowanego pakietu.

Xcodebuild man page

Przejdź do folderu, w którym znajduje się root twojego projektu i:

xcodebuild -project projectname -activetarget -activeconfiguration archive

Idąc o krok dalej, przesyłanie do iTunesConnect za pomocą linii poleceń Xcode 7 ! (Zakładając, że zaczynasz od znaku .ipa, który został podpisany przy użyciu prawidłowego profilu wydania i tożsamości podpisywania.)

Wprowadź altool, interfejs CLI dla programu ładującego aplikację(docs, str. 38). Ukryty głęboko w Xcode.struktura aplikacji, jest przydatną funkcją pozwalającą 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 uruchom $ altool --upload-app -f file -u username [-p password], aby wgrać swoje nowo wybite .ipa prosto do jabłka. Hasło jest opcjonalne i wyświetli monit o jego podanie, jeśli wyłączysz je z polecenia.

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

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

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

To jest to! Po prostu zaloguj się do iTunesConnect.com i wybierz swoją nową kompilację do testów za pomocą testflight.

Ostatnia Uwaga: Jeśli pojawi się błąd mówiąc Exception while launching iTunesTransporter: Transporter not found at path: /usr/local/itms/bin/iTMSTransporter. You should reinstall the application, możesz podążać za sugestią na to więc odpowiedź , 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 na archiwizację (generowanie IPA) projektu za pomocą wiersza poleceń. Pomyśl o tym jak o siostrze xcodebuild komendy, ale do archiwizacji.

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

Jedną z opcji skryptu jest umożliwienie archiwizacji symboli dSYM w archiwum z oznaczeniem czasu. Nie ma wymówki, aby nie trzymać już symboli i nie być w stanie symbol dziennika awarii, który możesz później otrzymać.

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 przydatne w przypadku ciągłej integracji. Posiada kilka dodatkowych funkcji:

1. uruchamia te same testy co Xcode.app.
2. strukturyzowane wyjście wyników budowania i testów.
Przyjazne dla człowieka, kolorowe wyjście ANSI.

Nr 3 jest niezwykle przydatny. Nie wiem czy ktoś potrafi odczytać wyjście konsoli z xcodebuild, nie mogę, zazwyczaj dał mi jeden linia z 5000 + znaków. Nawet trudniejsze do odczytania niż praca dyplomowa.

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

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

To zadanie jest bardzo proste:

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 odkryłem, ż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}" 

Polecenie nie może zostać uruchomione z powodu jakiegoś problemu z podpisem. The log wskazuje, że " warning: PackageApplication is deprecated, use Zamiast tego.

Masz na myśli opcje validate/share/submit? Myślę, że są one specyficzne dla Xcode, i nie nadaje się do wiersza poleceń budowania narzędzia.

Z odrobiną sprytu, założę się, że mógłbyś zrobić scenariusz, który zrobiłby to za Ciebie. Wygląda na to, że są przechowywane w ~/Library/MobileDevice/Archived Applications/ z UUDI i plist. Nie mogę sobie wyobrazić, że tak trudno byłoby odwrócić inżynierię walidatora.

Proces, który mnie interesuje to wysyłanie buildów do beta testerów. (Ponieważ przesyłanie App Store zdarza się rzadko, Nie mam nic przeciwko zrobieniu tego ręcznie, zwłaszcza, że często muszę dodać nowy tekst opisu.) Robiąc pseudo Build + archiwum za pomocą Xcode ' s CLI, mogę wyzwalać automatyczne buildy z każdego commita kodu, tworzyć pliki IPA z osadzonymi profilami provisioning i wysyłać je do testerów.