1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
/*
* Copyright 2007 The WebRTC Project Authors. All rights reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include <cstring>
#include <memory>
#include <sstream>
#include <sys/utsname.h>
#include "webrtc/base/checks.h"
#include "webrtc/base/logging.h"
#include "webrtc/base/macutils.h"
#include "webrtc/base/stringutils.h"
namespace rtc {
///////////////////////////////////////////////////////////////////////////////
bool ToUtf8(const CFStringRef str16, std::string* str8) {
if ((nullptr == str16) || (nullptr == str8)) {
return false;
}
size_t maxlen = CFStringGetMaximumSizeForEncoding(CFStringGetLength(str16),
kCFStringEncodingUTF8) + 1;
std::unique_ptr<char[]> buffer(new char[maxlen]);
if (!buffer || !CFStringGetCString(str16, buffer.get(), maxlen,
kCFStringEncodingUTF8)) {
return false;
}
str8->assign(buffer.get());
return true;
}
bool ToUtf16(const std::string& str8, CFStringRef* str16) {
if (nullptr == str16) {
return false;
}
*str16 = CFStringCreateWithBytes(kCFAllocatorDefault,
reinterpret_cast<const UInt8*>(str8.data()),
str8.length(), kCFStringEncodingUTF8,
false);
return nullptr != *str16;
}
void DecodeFourChar(UInt32 fc, std::string* out) {
std::stringstream ss;
ss << '\'';
bool printable = true;
for (int i = 3; i >= 0; --i) {
char ch = (fc >> (8 * i)) & 0xFF;
if (isprint(static_cast<unsigned char>(ch))) {
ss << ch;
} else {
printable = false;
break;
}
}
if (printable) {
ss << '\'';
} else {
ss.str("");
ss << "0x" << std::hex << fc;
}
out->append(ss.str());
}
static bool GetOSVersion(int* major, int* minor, int* bugfix) {
RTC_DCHECK(major && minor && bugfix);
struct utsname uname_info;
if (uname(&uname_info) != 0)
return false;
if (strcmp(uname_info.sysname, "Darwin") != 0)
return false;
*major = 10;
// The market version of macOS is always 4 lower than the internal version.
int minor_version = atoi(uname_info.release);
RTC_CHECK(minor_version >= 6);
*minor = minor_version - 4;
const char* dot = ::strchr(uname_info.release, '.');
if (!dot)
return false;
*bugfix = atoi(dot + 1);
return true;
}
MacOSVersionName GetOSVersionName() {
int major = 0, minor = 0, bugfix = 0;
if (!GetOSVersion(&major, &minor, &bugfix)) {
return kMacOSUnknown;
}
if (major > 10) {
return kMacOSNewer;
}
if ((major < 10) || (minor < 3)) {
return kMacOSOlder;
}
switch (minor) {
case 3:
return kMacOSPanther;
case 4:
return kMacOSTiger;
case 5:
return kMacOSLeopard;
case 6:
return kMacOSSnowLeopard;
case 7:
return kMacOSLion;
case 8:
return kMacOSMountainLion;
case 9:
return kMacOSMavericks;
}
return kMacOSNewer;
}
} // namespace rtc
|
