ios - sierra - sistema operativo mac os x

¿Cómo determino la versión del sistema operativo en tiempo de ejecución en OS X o iOS(sin usar Gestalt)?

Question

La función Gestalt () ubicada en CarbonCore/OSUtils.h ha quedado obsoleta a partir de OS X 10.8 Mountain Lion.

A menudo uso esta función para probar la versión del sistema operativo OS X en tiempo de ejecución (vea el ejemplo de juguete a continuación).

¿Qué otra API podría usarse para verificar la versión del sistema operativo OS X en tiempo de ejecución en una aplicación Cocoa?

int main() {
SInt32 versMaj, versMin, versBugFix;
Gestalt(gestaltSystemVersionMajor, &versMaj);
Gestalt(gestaltSystemVersionMinor, &versMin);
Gestalt(gestaltSystemVersionBugFix, &versBugFix);
printf("OS X Version: %d.%d.%d/n", versMaj, versMin, versBugFix);
}

Answer 1

En OS X 10.10 (y iOS 8.0), puede usar [[NSProcessInfo processInfo] operatingSystemVersion] que devuelve una estructura NSOperatingSystemVersion , definida como

typedef struct {
NSInteger majorVersion;
NSInteger minorVersion;
NSInteger patchVersion;
} NSOperatingSystemVersion;

También hay un método en NSProcessInfo que hará la comparación por usted:

- (BOOL)isOperatingSystemAtLeastVersion:(NSOperatingSystemVersion)version

Tenga cuidado , aunque está documentado que está disponible en OS X 10.10 y posterior, tanto operatingSystemVersion como isOperatingSystemAtLeastVersion: existen en OS X 10.9 ( probablemente 10.9.2 ) y funcionan como se esperaba. Significa que no debe probar si NSProcessInfo responde a estos selectores para verificar si se está ejecutando en OS X 10.9 o 10.10.

En iOS, estos métodos están efectivamente disponibles solo desde iOS 8.0.

Answer 2

En la línea de comando:

$ sysctl kern.osrelease
kern.osrelease: 12.0.0
$ sysctl kern.osversion
kern.osversion: 12A269

Programado:

#include <errno.h>
#include <sys/sysctl.h>
char str[256];
size_t size = sizeof(str);
int ret = sysctlbyname("kern.osrelease", str, &size, NULL, 0);

Versión de Darwin a la versión de OS X:

17.x.x. macOS 10.13.x High Sierra
16.x.x macOS 10.12.x Sierra
15.x.x OS X 10.11.x El Capitan
14.x.x OS X 10.10.x Yosemite
13.x.x OS X 10.9.x Mavericks
12.x.x OS X 10.8.x Mountain Lion
11.x.x OS X 10.7.x Lion
10.x.x OS X 10.6.x Snow Leopard
9.x.x OS X 10.5.x Leopard
8.x.x OS X 10.4.x Tiger
7.x.x OS X 10.3.x Panther
6.x.x OS X 10.2.x Jaguar
5.x OS X 10.1.x Puma

Una muestra para obtener y probar versiones:

#include <string.h>
#include <stdio.h>
#include <sys/sysctl.h>
/* kernel version as major minor component*/
struct kern {
short int version[3];
};
/* return the kernel version */
void GetKernelVersion(struct kern *k) {
static short int version_[3] = {0};
if (!version_[0]) {
// just in case it fails someday
version_[0] = version_[1] = version_[2] = -1;
char str[256] = {0};
size_t size = sizeof(str);
int ret = sysctlbyname("kern.osrelease", str, &size, NULL, 0);
if (ret == 0) sscanf(str, "%hd.%hd.%hd", &version_[0], &version_[1], &version_[2]);
}
memcpy(k->version, version_, sizeof(version_));
}
/* compare os version with a specific one
0 is equal
negative value if the installed version is less
positive value if the installed version is more
*/
int CompareKernelVersion(short int major, short int minor, short int component) {
struct kern k;
GetKernelVersion(&k);
if ( k.version[0] != major) return major - k.version[0];
if ( k.version[1] != minor) return minor - k.version[1];
if ( k.version[2] != component) return component - k.version[2];
return 0;
}
int main() {
struct kern kern;
GetKernelVersion(&kern);
printf("%hd %hd %hd/n", kern.version[0], kern.version[1], kern.version[2]);
printf("up: %d %d eq %d %d low %d %d/n",
CompareKernelVersion(17, 0, 0), CompareKernelVersion(16, 3, 0),
CompareKernelVersion(17, 3, 0), CompareKernelVersion(17,3,0),
CompareKernelVersion(17,5,0), CompareKernelVersion(18,3,0));
}

Resultado en mi máquina macOs High Sierra 10.13.2

17 3 0
up: -3 -1 eq 0 0 low 2 1

Answer 3

En realidad, se trata de una compilación de respuestas anteriores, con algunas pautas adicionales para el desarrollador que lo necesita.

OS-X proporciona su versión en tiempo de ejecución de varias maneras. Cada forma se ajusta mejor al escenario de desarrollo específico. Trataré de resumirlos todos, y espero que otros completen mi respuesta si olvidé algo.

Primero, la lista completa de formas de obtener la versión del sistema operativo.

1. La herramienta y la función de línea de comandos de uname proporcionan la versión de Unix (darwin) del sistema operativo. Aunque esta no es la versión comercial del sistema operativo, está alineada de forma única, por lo que puede deducir la versión comercial de OS-X.
2. sysctl kern.osrelease línea de comando sysctl kern.osrelease (o la función sysctlbyname("kern.osrelease", str, &size, NULL, 0) ) proporcionará la misma información que uname, marginalmente más fácil de analizar.
3. Gestalt(gestaltSystemVersionMajor) (con sus variantes " Minor " y BugFix "es la API más antigua (¡anterior al carbono!) Para obtener la versión del SO de marketing, aún respaldada por una versión obsoleta. Disponible en C desde el marco de CoreServices, pero no recomendado.
4. NSAppKitVersionNumber es una constante flotante de la NSAppKitVersionNumber , que proporcionará la versión de OS-X Appkit (alineada con la versión del sistema operativo), disponible para todas las aplicaciones que se vinculen con AppKit. También proporciona una enumeración completa de todas las versiones posibles (por ejemplo, NSAppKitVersionNumber10_7_2 )
5. kCFCoreFoundationVersionNumber es una constante flotante del marco de CoreFoundation, idéntica a la contraparte de Appkit, disponible para todas las aplicaciones vinculadas con CoreFoundation, tanto en C, Obj-C y Swift. También proporciona una enumeración completa de todas las versiones publicadas de OS X (p kCFCoreFoundationVersionNumber10_9 Ej., kCFCoreFoundationVersionNumber10_9 )
6. [[NSProcessInfo processInfo] operatingSystemVersionString]; es una Cocoa API disponible en Obj-C para aplicaciones OS-X e iOS.
7. Hay un .plist de recursos en /System/Library/CoreServices/SystemVersion.plist que, entre otras cosas, contiene la versión del sistema operativo en la clave "ProductVersion". NSProcessInfo lee su información de este archivo, pero puede hacerlo directamente utilizando su API de lectura PList.

Para obtener más detalles sobre cada opción, consulte las respuestas anteriores. ¡Hay mucha información allí!

Answer 4

Esto es lo que uso:

NSInteger osxVersion;
if (floor(NSAppKitVersionNumber) <= NSAppKitVersionNumber10_6) {
//10.6.x or earlier systems
osxVersion = 106;
NSLog(@"Mac OSX Snow Leopard");
} else if (floor(NSAppKitVersionNumber) <= NSAppKitVersionNumber10_7) {
/* On a 10.7 - 10.7.x system */
osxVersion = 107;
NSLog(@"Mac OSX Lion");
} else if (floor(NSAppKitVersionNumber) <= NSAppKitVersionNumber10_8) {
/* On a 10.8 - 10.8.x system */
osxVersion = 108;
NSLog(@"Mac OSX Moutain Lion");
} else {
/* 10.9 or later system */
osxVersion = 109;
NSLog(@"Mac OSX: Mavericks or Later");
}

Se recomienda en las Notas de la versión de AppKit

La lectura de /System/Library/CoreServices/SystemVersion.plist no es posible si la aplicación está en modo de espacio aislado

Answer 5

Existe el valor NSAppKitVersionNumber que puede usar para verificar las distintas versiones de AppKit, aunque no se corresponden exactamente con las versiones del sistema operativo.

if (NSAppKitVersionNumber <= NSAppKitVersionNumber10_7_2) {
NSLog (@"We are not running on Mountain Lion");
}

Answer 6

Hay uname(3) :

La función uname() almacena cadenas de información terminadas en nulos que identifican el sistema actual en la estructura a la que hace referencia el name .

La estructura utsname se define en el archivo de encabezado <sys/utsname.h> y contiene los siguientes miembros:

• sysname - Nombre de la implementación del sistema operativo.
• nodename - Nombre de red de esta máquina.
• release - Nivel de lanzamiento del sistema operativo.
• version - Nivel de versión del sistema operativo.
• machine - Plataforma de hardware de la máquina.

Answer 7

Hay una API de cacao. Puede obtener una cadena de versión de os X de la clase NSProcessInfo.

El código para obtener la cadena de versión del sistema operativo está debajo.

NSString * operatingSystemVersionString = [[NSProcessInfo processInfo] operatingSystemVersionString];
NSLog(@"operatingSystemVersionString => %@" , operatingSystemVersionString);

// === >> Versión 10.8.2 (Build 12C2034) valor de resultado

No está en desuso.

Answer 8

O, para decirlo de manera más simple, aquí está el código:

NSDictionary *version = [NSDictionary dictionaryWithContentsOfFile:@"/System/Library/CoreServices/SystemVersion.plist"];
NSString *productVersion = [version objectForKey:@"ProductVersion"];
NSLog (@"productVersion =========== %@", productVersion);

Espero que esto ayude a alguien.

Answer 9

Puede obtener fácilmente la versión de parche principal, menor, del sistema operativo utilizando NSOperatingSystemVersion

NSOperatingSystemVersion version = [[NSProcessInfo processInfo] operatingSystemVersion];
NSString* major = [NSString stringWithFormat:@"%d", version.majorVersion];
NSString* minor = [NSString stringWithFormat:@"%d", version.minorVersion];
NSString* patch = [NSString stringWithFormat:@"%d", version.patchVersion];

Answer 10

Si tiene una aplicación que necesita ejecutarse en 10.10, así como en versiones anteriores, aquí hay una solución:

typedef struct {
NSInteger majorVersion;
NSInteger minorVersion;
NSInteger patchVersion;
} MyOperatingSystemVersion;
if ([[NSProcessInfo processInfo] respondsToSelector:@selector(operatingSystemVersion)]) {
MyOperatingSystemVersion version = ((MyOperatingSystemVersion(*)(id, SEL))objc_msgSend_stret)([NSProcessInfo processInfo], @selector(operatingSystemVersion));
// do whatever you want with the version struct here
}
else {
UInt32 systemVersion = 0;
OSStatus err = Gestalt(gestaltSystemVersion, (SInt32 *) &systemVersion);
// do whatever you want with the systemVersion as before
}

Tenga en cuenta que incluso 10.9 parece responder al selector operatingSystemVersion, así que creo que solo era una API privada en 10.9 (pero aún funciona).

Esto funciona en todas las versiones de OS X y no depende del análisis sintáctico de cadenas ni de las E / S de archivos.

Answer 11

También hay kCFCoreFoundationVersionNumber que se puede usar si solo necesita comprobar si hay una versión mínima compatible. Esto tiene la ventaja de que funciona volviendo a 10.1 y se puede hacer en C, C ++ y Objective-C.

Por ejemplo, para verificar 10.10 o más:

#include <CoreFoundation/CoreFoundation.h>
if (floor(kCFCoreFoundationVersionNumber) > kCFCoreFoundationVersionNumber10_9) {
printf("On 10.10 or greater.");
}

Tendrá que vincularse con el marco de CoreFoundation (o Foundation).

También funciona en Swift de la misma manera. Aquí hay otro ejemplo:

import Foundation
if floor(kCFCoreFoundationVersionNumber) > kCFCoreFoundationVersionNumber10_8 {
println("On 10.9 or greater.")
} else if floor(kCFCoreFoundationVersionNumber) > kCFCoreFoundationVersionNumber10_9 {
println("On 10.10 or greater.")
}