获取ios设备信息

#import <UIKit/UIKit.h> 
 
@interface UIDevice (Info) 
 
+ (NSString *) device;               //设备类型(x86_64 iPod5,1) 
+ (NSString *) deviceModel;          //设备模式(iPad iPod iPhone) 
+ (NSString *) osVersion;            //系统版本 
+ (NSString *) os;                   //平台 
+ (NSString *) carrier;              //运营商 
+ (NSString *) resolution;           //分辨率 
+ (NSString *) locale;               //地域 
+ (NSString *) appVersion;           //程序版本 
+ (NSNumber *) timestamp;            //unix timestamp 
+ (NSString *) cpuType;              //cpu型号 
+ (NSString *) cpuFrequency;         //cpu频率 
+ (NSUInteger) cpuCount;             //cpu核数 
+ (NSArray  *) cpuUsage;             //cpu利用率 
+ (NSUInteger) totalMemoryBytes;     //获取手机内存总量,返回的是字节数 
+ (NSUInteger) freeMemoryBytes;      //获取手机可用内存,返回的是字节数 
+ (long  long) freeDiskSpaceBytes;   //获取手机硬盘空闲空间,返回的是字节数 
+ (long  long) totalDiskSpaceBytes;  //获取手机硬盘总空间,返回的是字节数 
+ (BOOL      ) isJailBreak;          //是否越狱 
+ (BOOL      ) bluetoothCheck;       //是否支持蓝牙 
 
@end 
import "UIDevice+Info.h" 
#import <CoreTelephony/CTTelephonyNetworkInfo.h> 
#import <CoreTelephony/CTCarrier.h> 
#import <mach/mach.h> 
#import <mach/mach_host.h> 
#import <sys/types.h> 
#import <sys/param.h> 
#import <sys/mount.h> 
#import <mach/processor_info.h> 
#include <sys/types.h> 
#include <sys/sysctl.h> 
#include <sys/socket.h> 
#include <sys/sysctl.h> 
#include <sys/stat.h> 
#include <net/if.h> 
#include <net/if_dl.h> 
 
 
 
#define IFPGA_NAMESTRING                @"iFPGA" 
 
#define IPHONE_1G_NAMESTRING            @"iPhone 1G" 
#define IPHONE_3G_NAMESTRING            @"iPhone 3G" 
#define IPHONE_3GS_NAMESTRING           @"iPhone 3GS" 
#define IPHONE_4_NAMESTRING             @"iPhone 4" 
#define IPHONE_4S_NAMESTRING            @"iPhone 4S" 
#define IPHONE_5_NAMESTRING             @"iPhone 5" 
#define IPHONE_UNKNOWN_NAMESTRING       @"Unknown iPhone" 
 
#define IPOD_1G_NAMESTRING              @"iPod touch 1G" 
#define IPOD_2G_NAMESTRING              @"iPod touch 2G" 
#define IPOD_3G_NAMESTRING              @"iPod touch 3G" 
#define IPOD_4G_NAMESTRING              @"iPod touch 4G" 
#define IPOD_UNKNOWN_NAMESTRING         @"Unknown iPod" 
 
#define IPAD_1G_NAMESTRING              @"iPad 1G" 
#define IPAD_2G_NAMESTRING              @"iPad 2G" 
#define IPAD_3G_NAMESTRING              @"iPad 3G" 
#define IPAD_4G_NAMESTRING              @"iPad 4G" 
#define IPAD_UNKNOWN_NAMESTRING         @"Unknown iPad" 
 
#define APPLETV_2G_NAMESTRING           @"Apple TV 2G" 
#define APPLETV_3G_NAMESTRING           @"Apple TV 3G" 
#define APPLETV_4G_NAMESTRING           @"Apple TV 4G" 
#define APPLETV_UNKNOWN_NAMESTRING      @"Unknown Apple TV" 
 
#define IOS_FAMILY_UNKNOWN_DEVICE       @"Unknown iOS device" 
 
#define SIMULATOR_NAMESTRING            @"iPhone Simulator" 
#define SIMULATOR_IPHONE_NAMESTRING     @"iPhone Simulator" 
#define SIMULATOR_IPAD_NAMESTRING       @"iPad Simulator" 
#define SIMULATOR_APPLETV_NAMESTRING    @"Apple TV Simulator" // 
 
//iPhone 3G 以后各代的CPU型号和频率 
#define IPHONE_3G_CPUTYPE               @"ARM11" 
#define IPHONE_3G_CPUFREQUENCY          @"412MHz" 
#define IPHONE_3GS_CPUTYPE              @"ARM Cortex A8" 
#define IPHONE_3GS_CPUFREQUENCY         @"600MHz" 
#define IPHONE_4_CPUTYPE                @"Apple A4" 
#define IPHONE_4_CPUFREQUENCY           @"1GMHz" 
#define IPHONE_4S_CPUTYPE               @"Apple A5 Double Core" 
#define IPHONE_4S_CPUFREQUENCY          @"800MHz" 
 
//iPod touch 4G 的CPU型号和频率 
#define IPOD_4G_CPUTYPE                 @"Apple A4" 
#define IPOD_4G_CPUFREQUENCY            @"800MHz" 
 
#define IOS_CPUTYPE_UNKNOWN             @"Unknown CPU type" 
#define IOS_CPUFREQUENCY_UNKNOWN        @"Unknown CPU frequency" 
 
typedef enum { 
    UIDeviceUnknown, 
     
    UIDeviceSimulator, 
    UIDeviceSimulatoriPhone, 
    UIDeviceSimulatoriPad, 
    UIDeviceSimulatorAppleTV, 
     
    UIDevice1GiPhone, 
    UIDevice3GiPhone, 
    UIDevice3GSiPhone, 
    UIDevice4iPhone, 
    UIDevice4SiPhone, 
    UIDevice5iPhone, 
     
    UIDevice1GiPod, 
    UIDevice2GiPod, 
    UIDevice3GiPod, 
    UIDevice4GiPod, 
     
    UIDevice1GiPad, 
    UIDevice2GiPad, 
    UIDevice3GiPad, 
    UIDevice4GiPad, 
     
    UIDeviceAppleTV2, 
    UIDeviceAppleTV3, 
    UIDeviceAppleTV4, 
     
    UIDeviceUnknowniPhone, 
    UIDeviceUnknowniPod, 
    UIDeviceUnknowniPad, 
    UIDeviceUnknownAppleTV, 
    UIDeviceIFPGA, 
     
} UIDevicePlatform; 
 
typedef enum { 
    UIDeviceFamilyiPhone, 
    UIDeviceFamilyiPod, 
    UIDeviceFamilyiPad, 
    UIDeviceFamilyAppleTV, 
    UIDeviceFamilyUnknown, 
     
} UIDeviceFamily; 
 
@implementation UIDevice (Info) 
 
+ (NSString *)device 
{ 
    size_t size; 
    sysctlbyname("hw.machine", NULL, &size, NULL, 0); 
    charchar *machine = malloc(size); 
    sysctlbyname("hw.machine", machine, &size, NULL, 0); 
    NSString *platform = [NSString stringWithUTF8String:machine]; 
    free(machine); 
    return platform; 
} 
 
+ (NSString *) deviceModel 
{ 
    NSString *model = [[UIDevice currentDevice] model]; 
    if ([model hasPrefix:@"iPad"]) { 
        return @"iPad"; 
    } else if ([model hasPrefix:@"iPod"]) { 
        return @"iPod"; 
    } else if ([model hasPrefix:@"iPhone"]){ 
        return @"iPhone"; 
    } 
     
    return nil; 
} 
 
+ (NSString *)osVersion 
{ 
    return [[UIDevice currentDevice] systemVersion]; 
} 
 
+ (NSString*)os 
{ 
    return @"iOS"; 
} 
 
+ (NSString *)carrier 
{ 
    if (NSClassFromString(@"CTTelephonyNetworkInfo")) 
    { 
        CTTelephonyNetworkInfo *netinfo = [[[CTTelephonyNetworkInfo alloc] init] autorelease]; 
        CTCarrier *carrier = [netinfo subscriberCellularProvider]; 
        return [carrier carrierName]; 
    } 
     
    return @""; 
} 
 
+ (NSString *)resolution 
{ 
    CGRect bounds = [[UIScreen mainScreen] bounds]; 
    CGFloat scale = [[UIScreen mainScreen] respondsToSelector:@selector(scale)] ? [[UIScreen mainScreen] scale] : 1.f; 
    CGSize res = CGSizeMake(bounds.size.width * scale, bounds.size.height * scale); 
    NSString *result = [NSString stringWithFormat:@"%gx%g", res.width, res.height]; 
     
    return result; 
} 
 
+ (NSString *)locale 
{ 
    return [[NSLocale currentLocale] localeIdentifier]; 
} 
 
+ (NSString *)appVersion 
{ 
    return [[[NSBundle mainBundle] infoDictionary] objectForKey:(NSString*)kCFBundleVersionKey]; 
} 
 
+ (NSNumber *)timestamp 
{ 
    return [NSNumber numberWithLong:time(NULL)]; 
} 
 
#pragma mark sysctlbyname utils 
+ (NSString *) getSysInfoByName:(charchar *)typeSpecifier 
{ 
    size_t size; 
    sysctlbyname(typeSpecifier, NULL, &size, NULL, 0); 
     
    charchar *answer = malloc(size); 
    sysctlbyname(typeSpecifier, answer, &size, NULL, 0); 
     
    NSString *results = [NSString stringWithCString:answer encoding: NSUTF8StringEncoding]; 
     
    free(answer); 
    return results; 
} 
 
#pragma mark platform information 
+ (NSString *) platform 
{ 
    return [self getSysInfoByName:"hw.machine"]; 
} 
 
+ (NSUInteger) platformType 
{ 
    NSString *platform = [self platform]; 
     
    // The ever mysterious iFPGA 
    if ([platform isEqualToString:@"iFPGA"])        return UIDeviceIFPGA; 
     
    // iPhone 
    if ([platform isEqualToString:@"iPhone1,1"])    return UIDevice1GiPhone; 
    if ([platform isEqualToString:@"iPhone1,2"])    return UIDevice3GiPhone; 
    if ([platform hasPrefix:@"iPhone2"])            return UIDevice3GSiPhone; 
    if ([platform hasPrefix:@"iPhone3"])            return UIDevice4iPhone; 
    if ([platform hasPrefix:@"iPhone4"])            return UIDevice4SiPhone; 
    if ([platform hasPrefix:@"iPhone5"])            return UIDevice5iPhone; 
     
    // iPod 
    if ([platform hasPrefix:@"iPod1"])              return UIDevice1GiPod; 
    if ([platform hasPrefix:@"iPod2"])              return UIDevice2GiPod; 
    if ([platform hasPrefix:@"iPod3"])              return UIDevice3GiPod; 
    if ([platform hasPrefix:@"iPod4"])              return UIDevice4GiPod; 
     
    // iPad 
    if ([platform hasPrefix:@"iPad1"])              return UIDevice1GiPad; 
    if ([platform hasPrefix:@"iPad2"])              return UIDevice2GiPad; 
    if ([platform hasPrefix:@"iPad3"])              return UIDevice3GiPad; 
    if ([platform hasPrefix:@"iPad4"])              return UIDevice4GiPad; 
     
    // Apple TV 
    if ([platform hasPrefix:@"AppleTV2"])           return UIDeviceAppleTV2; 
    if ([platform hasPrefix:@"AppleTV3"])           return UIDeviceAppleTV3; 
     
    if ([platform hasPrefix:@"iPhone"])             return UIDeviceUnknowniPhone; 
    if ([platform hasPrefix:@"iPod"])               return UIDeviceUnknowniPod; 
    if ([platform hasPrefix:@"iPad"])               return UIDeviceUnknowniPad; 
    if ([platform hasPrefix:@"AppleTV"])            return UIDeviceUnknownAppleTV; 
     
    // Simulator thanks Jordan Breeding 
    if ([platform hasSuffix:@"86"] || [platform isEqual:@"x86_64"]) 
    { 
        BOOL smallerScreen = [[UIScreen mainScreen] bounds].size.width < 768; 
        return smallerScreen ? UIDeviceSimulatoriPhone : UIDeviceSimulatoriPad; 
    } 
     
    return UIDeviceUnknown; 
} 
 
+ (NSString *) platformString 
{ 
    switch ([self platformType]) 
    { 
        case UIDevice1GiPhone: return IPHONE_1G_NAMESTRING; 
        case UIDevice3GiPhone: return IPHONE_3G_NAMESTRING; 
        case UIDevice3GSiPhone: return IPHONE_3GS_NAMESTRING; 
        case UIDevice4iPhone: return IPHONE_4_NAMESTRING; 
        case UIDevice4SiPhone: return IPHONE_4S_NAMESTRING; 
        case UIDevice5iPhone: return IPHONE_5_NAMESTRING; 
        case UIDeviceUnknowniPhone: return IPHONE_UNKNOWN_NAMESTRING; 
             
        case UIDevice1GiPod: return IPOD_1G_NAMESTRING; 
        case UIDevice2GiPod: return IPOD_2G_NAMESTRING; 
        case UIDevice3GiPod: return IPOD_3G_NAMESTRING; 
        case UIDevice4GiPod: return IPOD_4G_NAMESTRING; 
        case UIDeviceUnknowniPod: return IPOD_UNKNOWN_NAMESTRING; 
             
        case UIDevice1GiPad : return IPAD_1G_NAMESTRING; 
        case UIDevice2GiPad : return IPAD_2G_NAMESTRING; 
        case UIDevice3GiPad : return IPAD_3G_NAMESTRING; 
        case UIDevice4GiPad : return IPAD_4G_NAMESTRING; 
        case UIDeviceUnknowniPad : return IPAD_UNKNOWN_NAMESTRING; 
             
        case UIDeviceAppleTV2 : return APPLETV_2G_NAMESTRING; 
        case UIDeviceAppleTV3 : return APPLETV_3G_NAMESTRING; 
        case UIDeviceAppleTV4 : return APPLETV_4G_NAMESTRING; 
        case UIDeviceUnknownAppleTV: return APPLETV_UNKNOWN_NAMESTRING; 
             
        case UIDeviceSimulator: return SIMULATOR_NAMESTRING; 
        case UIDeviceSimulatoriPhone: return SIMULATOR_IPHONE_NAMESTRING; 
        case UIDeviceSimulatoriPad: return SIMULATOR_IPAD_NAMESTRING; 
        case UIDeviceSimulatorAppleTV: return SIMULATOR_APPLETV_NAMESTRING; 
             
        case UIDeviceIFPGA: return IFPGA_NAMESTRING; 
             
        default: return IOS_FAMILY_UNKNOWN_DEVICE; 
    } 
} 
 
#pragma mark sysctl utils 
+ (NSUInteger) getSysInfo: (uint) typeSpecifier 
{ 
    size_t size = sizeof(int); 
    int results; 
    int mib[2] = {CTL_HW, typeSpecifier}; 
    sysctl(mib, 2, &results, &size, NULL, 0); 
    return (NSUInteger) results; 
} 
 
#pragma mark cpu information 
+ (NSString *) cpuType 
{ 
    switch ([self platformType]) 
    { 
        case UIDevice3GiPhone: return IPHONE_3G_CPUTYPE; 
        case UIDevice3GSiPhone: return IPHONE_3GS_CPUTYPE; 
        case UIDevice4iPhone: return IPHONE_4_CPUTYPE; 
        case UIDevice4SiPhone: return IPHONE_4S_CPUTYPE; 
        case UIDevice4GiPod: return IPOD_4G_CPUTYPE; 
        default: return IOS_CPUTYPE_UNKNOWN; 
    } 
} 
 
+ (NSString *) cpuFrequency 
{ 
    switch ([self platformType]) 
    { 
        case UIDevice3GiPhone: return IPHONE_3G_CPUFREQUENCY; 
        case UIDevice3GSiPhone: return IPHONE_3GS_CPUFREQUENCY; 
        case UIDevice4iPhone: return IPHONE_4_CPUFREQUENCY; 
        case UIDevice4SiPhone: return IPHONE_4S_CPUFREQUENCY; 
        case UIDevice4GiPod: return IPOD_4G_CPUFREQUENCY; 
        default: return IOS_CPUFREQUENCY_UNKNOWN; 
    } 
} 
 
+ (NSUInteger) cpuCount 
{ 
    return [self getSysInfo:HW_NCPU]; 
} 
 
+ (NSArray *)cpuUsage 
{ 
    NSMutableArray *usage = [NSMutableArray array]; 
    //    float usage = 0; 
    processor_info_array_t _cpuInfo, _prevCPUInfo = nil; 
    mach_msg_type_number_t _numCPUInfo, _numPrevCPUInfo = 0; 
    unsigned _numCPUs; 
    NSLock *_cpuUsageLock; 
     
    int _mib[2U] = { CTL_HW, HW_NCPU }; 
    size_t _sizeOfNumCPUs = sizeof(_numCPUs); 
    int _status = sysctl(_mib, 2U, &_numCPUs, &_sizeOfNumCPUs, NULL, 0U); 
    if(_status) 
        _numCPUs = 1; 
     
    _cpuUsageLock = [[NSLock alloc] init]; 
     
    natural_t _numCPUsU = 0U; 
    kern_return_t err = host_processor_info(mach_host_self(), PROCESSOR_CPU_LOAD_INFO, &_numCPUsU, &_cpuInfo, &_numCPUInfo); 
    if(err == KERN_SUCCESS) { 
        [_cpuUsageLock lock]; 
         
        for(unsigned i = 0U; i < _numCPUs; ++i) { 
            Float32 _inUse, _total; 
            if(_prevCPUInfo) { 
                _inUse = ( 
                          (_cpuInfo[(CPU_STATE_MAX * i) + CPU_STATE_USER]   - _prevCPUInfo[(CPU_STATE_MAX * i) + CPU_STATE_USER]) 
                          + (_cpuInfo[(CPU_STATE_MAX * i) + CPU_STATE_SYSTEM] - _prevCPUInfo[(CPU_STATE_MAX * i) + CPU_STATE_SYSTEM]) 
                          + (_cpuInfo[(CPU_STATE_MAX * i) + CPU_STATE_NICE]   - _prevCPUInfo[(CPU_STATE_MAX * i) + CPU_STATE_NICE]) 
                          ); 
                _total = _inUse + (_cpuInfo[(CPU_STATE_MAX * i) + CPU_STATE_IDLE] - _prevCPUInfo[(CPU_STATE_MAX * i) + CPU_STATE_IDLE]); 
            } else { 
                _inUse = _cpuInfo[(CPU_STATE_MAX * i) + CPU_STATE_USER] + _cpuInfo[(CPU_STATE_MAX * i) + CPU_STATE_SYSTEM] + _cpuInfo[(CPU_STATE_MAX * i) + CPU_STATE_NICE]; 
                _total = _inUse + _cpuInfo[(CPU_STATE_MAX * i) + CPU_STATE_IDLE]; 
            } 
             
            //            NSLog(@"Core : %u, Usage: %.2f%%", i, _inUse / _total * 100.f); 
            float u = _inUse / _total * 100.f; 
            [usage addObject:[NSNumber numberWithFloat:u]]; 
        } 
         
        [_cpuUsageLock unlock]; 
         
        if(_prevCPUInfo) { 
            size_t prevCpuInfoSize = sizeof(integer_t) * _numPrevCPUInfo; 
            vm_deallocate(mach_task_self(), (vm_address_t)_prevCPUInfo, prevCpuInfoSize); 
        } 
         
        _prevCPUInfo = _cpuInfo; 
        _numPrevCPUInfo = _numCPUInfo; 
         
        _cpuInfo = nil; 
        _numCPUInfo = 0U; 
    } else { 
        NSLog(@"Error!"); 
    } 
    return usage; 
} 
 
#pragma mark memory information 
+ (NSUInteger) totalMemoryBytes 
{ 
    return [self getSysInfo:HW_PHYSMEM]; 
} 
 
+ (NSUInteger) freeMemoryBytes 
{ 
    mach_port_t           host_port = mach_host_self(); 
    mach_msg_type_number_t   host_size = sizeof(vm_statistics_data_t) / sizeof(integer_t); 
    vm_size_t               pagesize; 
    vm_statistics_data_t     vm_stat; 
     
    host_page_size(host_port, &pagesize); 
     
    if (host_statistics(host_port, HOST_VM_INFO, (host_info_t)&vm_stat, &host_size) != KERN_SUCCESS) NSLog(@"Failed to fetch vm statistics"); 
     
    //    natural_t   mem_used = (vm_stat.active_count + vm_stat.inactive_count + vm_stat.wire_count) * pagesize; 
    natural_t   mem_free = vm_stat.free_count * pagesize; 
    //    natural_t   mem_total = mem_used + mem_free; 
     
    return mem_free; 
} 
 
#pragma mark disk information 
+ (long long) freeDiskSpaceBytes 
{ 
    struct statfs buf; 
    long long freespace; 
    freespace = 0; 
    if(statfs("/private/var", &buf) >= 0){ 
        freespace = (long long)buf.f_bsize * buf.f_bfree; 
    } 
    return freespace; 
} 
 
+ (long long) totalDiskSpaceBytes 
{ 
    struct statfs buf; 
    long long totalspace; 
    totalspace = 0; 
    if(statfs("/private/var", &buf) >= 0){ 
        totalspace = (long long)buf.f_bsize * buf.f_blocks; 
    } 
    return totalspace; 
} 
 
+ (BOOL) isJailBreak 
{ 
//    int res = access("/var/mobile/Library/AddressBook/AddressBook.sqlitedb", F_OK); 
//    if (res != 0) 
//        return NO; 
//    return YES; 
     
    BOOL jailbroken = NO; 
    NSString *cydiaPath = @"/Applications/Cydia.app"; 
    NSString *aptPath = @"/private/var/lib/apt/"; 
    if ([[NSFileManager defaultManager] fileExistsAtPath:cydiaPath]) { 
        jailbroken = YES; 
    } 
    if ([[NSFileManager defaultManager] fileExistsAtPath:aptPath]) { 
        jailbroken = YES; 
    } 
    return jailbroken; 
} 
 
#pragma mark bluetooth information 
+ (BOOL) bluetoothCheck 
{ 
    switch ([self platformType]) 
    { 
        case UIDevice3GiPhone: return YES; 
        case UIDevice3GSiPhone: return YES; 
        case UIDevice4iPhone: return YES; 
        case UIDevice4SiPhone: return YES; 
        case UIDevice5iPhone: return YES; 
             
        case UIDevice3GiPod: return YES; 
        case UIDevice4GiPod: return YES; 
             
        case UIDevice1GiPad : return YES; 
        case UIDevice2GiPad : return YES; 
        case UIDevice3GiPad : return YES; 
        case UIDevice4GiPad : return YES; 
             
        default: return NO; 
    } 
} 
 
@end