iOS开发～设备信息

来源：互联网发布：计数排序java实现编辑：程序博客网时间：2024/06/10 10:20

参考了很多帖子，最后根据项目需求，修正了一些错误，总结了一个相对更全面一些的公用模块：

[objc] view plaincopyprint?
#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  

[objc] view plaincopyprint?
#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  

0 0