Jak mówi pytanie, chciałbym głównie wiedzieć, czy mój kod działa w symulatorze, ale chciałbym również wiedzieć, która konkretna wersja iPhone'a jest uruchomiona lub symulowana.

EDYCJA: Dodałem słowo „programowo” do nazwy pytania. Chodzi mi o to, aby móc dynamicznie dołączać / wykluczać kod w zależności od uruchomionej wersji / symulatora, więc naprawdę szukałbym czegoś w rodzaju dyrektywy przedprocesorowej, która mogłaby dostarczyć mi tych informacji.

Już zadałem, ale z zupełnie innym tytułem.

Co #defines są konfigurowane przez Xcode podczas kompilacji na iPhone'a

Stamtąd powtórzę moją odpowiedź:

Jest w dokumentacji SDK w sekcji „Warunkowe kompilowanie kodu źródłowego”

Odpowiednia definicja to TARGET_OS_SIMULATOR, który jest zdefiniowany w /usr/include/TargetConditionals.h w ramach systemu iOS. We wcześniejszych wersjach zestawu narzędzi trzeba było napisać:

#include "TargetConditionals.h"

ale nie jest to już konieczne w bieżącym łańcuchu narzędzi (Xcode 6 / iOS8).

Na przykład, jeśli chcesz sprawdzić, czy działasz na urządzeniu, powinieneś to zrobić

#if TARGET_OS_SIMULATOR
    // Simulator-specific code
#else
    // Device-specific code
#endif

w zależności od tego, który jest odpowiedni dla twojego przypadku użycia.

Zaktualizowany kod:

Podobno działa to oficjalnie.

#if TARGET_IPHONE_SIMULATOR
NSString *hello = @"Hello, iPhone simulator!";
#elif TARGET_OS_IPHONE
NSString *hello = @"Hello, device!";
#else
NSString *hello = @"Hello, unknown target!";
#endif

Oryginalny post (od wycofania)

Ten kod powie ci, czy korzystasz z symulatora.

#ifdef __i386__
NSLog(@"Running in the simulator");
#else
NSLog(@"Running on a device");
#endif

Nie była to dyrektywa przedprocesowa, ale tego właśnie szukałam, kiedy doszłam do tego pytania;

NSString *model = [[UIDevice currentDevice] model];
if ([model isEqualToString:@"iPhone Simulator"]) {
    //device is simulator
}

Najlepszym sposobem na to jest:

#if TARGET_IPHONE_SIMULATOR

i nie

#ifdef TARGET_IPHONE_SIMULATOR

ponieważ zawsze jest zdefiniowany: 0 lub 1

TERAZ JEST LEPSZY SPOSÓB!

Począwszy od wersji Xcode 9.3 beta 4 można #if targetEnvironment(simulator)to sprawdzić.

#if targetEnvironment(simulator)
//Your simulator code
#endif

AKTUALIZACJA
Xcode 10 i iOS 12 SDK również to obsługuje.

W przypadku Swift możemy wprowadzić następujące

Możemy stworzyć strukturę, która pozwala tworzyć dane strukturalne

struct Platform {
    static var isSimulator: Bool {
        #if targetEnvironment(simulator)
            // We're on the simulator
            return true
        #else
            // We're on a device
             return false
        #endif
    }
}

Następnie, jeśli chcemy wykryć, czy w Swift jest budowana aplikacja na urządzenie lub symulator.

if Platform.isSimulator {
    // Do one thing
} else {
    // Do the other
}

Działa dla Swift 5iXcode 11.3.1

Użyj tego kodu:

#if targetEnvironment(simulator)
   // Simulator
#else
   // Device
#endif

Wszystkie te odpowiedzi są dobre, ale jakoś wprawia w zakłopotanie początkującego, jak ja, ponieważ nie wyjaśnia kontroli kompilacji i kontroli środowiska uruchomieniowego. Preprocesor jest przed czasem kompilacji, ale powinniśmy to wyjaśnić

W tym artykule na blogu pokazano, jak wykryć symulator iPhone'a? Wyraźnie

Środowisko wykonawcze

Po pierwsze, omówmy krótko. UIDevice zapewnia już informacje o urządzeniu

[[UIDevice currentDevice] model]

zwróci Ci „iPhone Simulator” lub „iPhone” w zależności od tego, gdzie aplikacja jest uruchomiona.

Czas kompilacji

Jednak chcesz zdefiniować czas kompilacji. Czemu? Ponieważ twoją aplikację kompilujesz wyłącznie w celu uruchomienia jej w symulatorze lub na urządzeniu. Apple tworzy definicję o nazwie TARGET_IPHONE_SIMULATOR. Spójrzmy więc na kod:

#if TARGET_IPHONE_SIMULATOR

NSLog(@"Running in Simulator - no app store or giro");

#endif

Poprzednie odpowiedzi są trochę przestarzałe. Odkryłem, że wszystko, co musisz zrobić, to wysłać zapytanie do TARGET_IPHONE_SIMULATORmakra ( nie musisz dołączać żadnych innych plików nagłówkowych [zakładając, że kodujesz dla iOS]).

Próbowałem, TARGET_OS_IPHONEale zwróciło tę samą wartość (1) podczas działania na rzeczywistym urządzeniu i symulatorze, dlatego zalecam użycie TARGET_IPHONE_SIMULATORzamiast tego.

W krótkim:

#if (arch(i386) || arch(x86_64))
...            
#endif

Od Wykryj, czy aplikacja Swift buduje aplikację na urządzenie lub symulator

Miałem ten sam problem, jak TARGET_IPHONE_SIMULATORi TARGET_OS_IPHONEzawsze są zdefiniowane i są ustawione na 1. prac rozwiązań Pete'a, oczywiście, ale jeśli kiedykolwiek zdarzy się budować na czymś innym niż Intel (mało prawdopodobne, ale kto wie), tutaj jest coś, co jest bezpieczne, jak tak długo, jak sprzęt iPhone'a się nie zmieni (więc Twój kod zawsze będzie działał dla obecnie dostępnych telefonów):

#if defined __arm__ || defined __thumb__
#undef TARGET_IPHONE_SIMULATOR
#define TARGET_OS_IPHONE
#else
#define TARGET_IPHONE_SIMULATOR 1
#undef TARGET_OS_IPHONE
#endif

Umieść to w dogodnym miejscu, a następnie udawaj, że TARGET_*stałe zostały poprawnie zdefiniowane.

Czy ktoś rozważał udzieloną tutaj odpowiedź ?

Przypuszczam, że byłby to odpowiednik celu-c

+ (BOOL)isSimulator {
    NSOperatingSystemVersion ios9 = {9, 0, 0};
    NSProcessInfo *processInfo = [NSProcessInfo processInfo];
    if ([processInfo isOperatingSystemAtLeastVersion:ios9]) {
        NSDictionary<NSString *, NSString *> *environment = [processInfo environment];
        NSString *simulator = [environment objectForKey:@"SIMULATOR_DEVICE_NAME"];
        return simulator != nil;
    } else {
        UIDevice *currentDevice = [UIDevice currentDevice];
        return ([currentDevice.model rangeOfString:@"Simulator"].location != NSNotFound);
    }
}

Dla Swift 4.2 / xCode 10

Utworzyłem rozszerzenie na UIDevice, dzięki czemu mogę łatwo zapytać, czy symulator jest uruchomiony.

// UIDevice+CheckSimulator.swift

import UIKit

extension UIDevice {

    /// Checks if the current device that runs the app is xCode's simulator
    static func isSimulator() -> Bool {        
        #if targetEnvironment(simulator)
            return true
        #else
            return false
        #endif
    }
}

Na przykład w aplikacji AppDelegate korzystam z tej metody, aby zdecydować, czy konieczna jest rejestracja w celu zdalnego powiadomienia, co nie jest możliwe w symulatorze.

// CHECK FOR REAL DEVICE / OR SIMULATOR
if UIDevice.isSimulator() == false {

    // REGISTER FOR SILENT REMOTE NOTIFICATION
    application.registerForRemoteNotifications()
}

Aby uwzględnić wszystkie typy „symulatorów”

NSString *model = [[UIDevice currentDevice] model];
if([model rangeOfString:@"Simulator" options:NSCaseInsensitiveSearch].location !=NSNotFound)
{
    // we are running in a simulator
}

Dzięki Swift 4.2 (Xcode 10) możemy to zrobić

#if targetEnvironment(simulator)
  //simulator code
#else 
  #warning("Not compiling for simulator")
#endif

Moja odpowiedź oparta jest na odpowiedzi @Daniel Magnusson i komentarzach @Nuthatch i @ n.Drake. i piszę to, aby zaoszczędzić trochę czasu szybkim użytkownikom pracującym na iOS9 i nowszych.

Oto, co zadziałało dla mnie:

if UIDevice.currentDevice().name.hasSuffix("Simulator"){
    //Code executing on Simulator
} else{
    //Code executing on Device
}

/// Zwraca wartość true, jeśli jest to symulator, a nie urządzenie

public static var isSimulator: Bool {
    #if (arch(i386) || arch(x86_64)) && os(iOS)
        return true
    #else
        return false
    #endif
}

Firma Apple dodała obsługę sprawdzania, czy aplikacja jest przeznaczona dla symulatora, w następujący sposób:

#if targetEnvironment(simulator)
let DEVICE_IS_SIMULATOR = true
#else
let DEVICE_IS_SIMULATOR = false
#endif

jeśli nic nie działało, spróbuj tego

public struct Platform {

    public static var isSimulator: Bool {
        return TARGET_OS_SIMULATOR != 0 // Use this line in Xcode 7 or newer
    }

}

Moim zdaniem odpowiedź (przedstawiona powyżej i powtórzona poniżej):

NSString *model = [[UIDevice currentDevice] model];
if ([model isEqualToString:@"iPhone Simulator"]) {
    //device is simulator
}

jest najlepszą odpowiedzią, ponieważ jest oczywiście wykonywana w RUNTIME w porównaniu do DYREKTYWY KOMPILACYJNEJ.

To działało dla mnie najlepiej

NSString *name = [[UIDevice currentDevice] name];


if ([name isEqualToString:@"iPhone Simulator"]) {

}