src/system_info_platform.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <unistd.h>
  21 #include <string.h>
  22 #include <ctype.h>
  23 #include <sys/types.h>
  24 #include <sys/stat.h>
  25 #include <fcntl.h>
  26
  27 #include <dlog.h>
  28 #include <vconf.h>
  29
  30 #include <system_info.h>
  31 #include <system_info_private.h>
  32
  33 #include <GLES/gl.h>
  34 #include <GLES/glext.h>
  35
  36 #ifdef LOG_TAG
  37 #undef LOG_TAG
  38 #endif
  39
  40 #define LOG_TAG "CAPI_SYSTEM_INFO"
  41
  42 #define LIB_GLES_V1 "/usr/lib/libGLESv1_CM.so"
  43 #define LIB_GLES_V2 "/usr/lib/libGLESv2.so"
  44
  45 #define SIZE_OF_MODEL_NAME 8
  46
  47 int system_info_get_model(system_info_key_e key, system_info_data_type_e data_type, void **value)
  48 {
  49         char *MODEL = NULL;
  50         char *name = NULL;
  51         char str[MAXBUFSIZE];
  52         char tmpStr[MAXBUFSIZE];
  53         int tmpStrlen = 0;
  54         FILE *info;
  55         extern char *strcasestr(const char *s, const char *find);
  56
  57         info = fopen(INFO_FILE_PATH, "r");
  58         if (NULL == info) {
  59                 LOGE("cannot file open %s file!!!", INFO_FILE_PATH);
  60                 return SYSTEM_INFO_ERROR_IO_ERROR;
  61         } else {
  62                 while (fgets(str, MAXBUFSIZE, info)) {
  63                         if (strcasestr(str, "Model")) {
  64                                 name = strchr(str, '=');
  65                                 name++;
  66                                 tmpStrlen = strlen(name);
  67
  68                                 strncpy(tmpStr, name, tmpStrlen-2);
  69                                 tmpStr[tmpStrlen-2] = '\0';
  70
  71                                 MODEL = strdup(tmpStr);
  72                                 if (MODEL == NULL) {
  73                                         LOGE("OUT_OF_MEMORY(0x%08x)", SYSTEM_INFO_ERROR_OUT_OF_MEMORY);
  74                                         fclose(info);
  75                                         return SYSTEM_INFO_ERROR_OUT_OF_MEMORY;
  76                                 }
  77                                 break;
  78                         } else
  79                                 continue;
  80                 }
  81         }
  82         *value = MODEL;
  83         fclose(info);
  84         return SYSTEM_INFO_ERROR_NONE;
  85 }
  86
  87 int system_info_get_tizen_version(system_info_key_e key, system_info_data_type_e data_type, void **value)
  88 {
  89         char *TIZEN_VERSION = NULL;
  90         char *name = NULL;
  91         char str[MAXBUFSIZE];
  92         char tmpStr[MAXBUFSIZE];
  93         int tmpStrlen = 0;
  94         FILE *info;
  95         extern char *strcasestr(const char *s, const char *find);
  96
  97         info = fopen(OS_RELEASE_FILE_PATH, "r");
  98         if (NULL == info) {
  99                 LOGE("cannot file open %s file!!!", OS_RELEASE_FILE_PATH);
 100                 return SYSTEM_INFO_ERROR_IO_ERROR;
 101         } else {
 102                 while (fgets(str, MAXBUFSIZE, info)) {
 103                         if (strcasestr(str, "VERSION_ID")) {
 104                                 name = strchr(str, '=');
 105                                 name += 2;
 106                                 tmpStrlen = strlen(name);
 107
 108                                 strncpy(tmpStr, name, tmpStrlen-2);
 109                                 tmpStr[tmpStrlen-2] = '\0';
 110
 111                                 TIZEN_VERSION = strdup(tmpStr);
 112                                 if (TIZEN_VERSION == NULL) {
 113                                         LOGE("OUT_OF_MEMORY(0x%08x)", SYSTEM_INFO_ERROR_OUT_OF_MEMORY);
 114                                         fclose(info);
 115                                         return SYSTEM_INFO_ERROR_OUT_OF_MEMORY;
 116                                 }
 117                                 break;
 118                         } else
 119                                 continue;
 120                 }
 121         }
 122         *value = TIZEN_VERSION;
 123         fclose(info);
 124         return SYSTEM_INFO_ERROR_NONE;
 125 }
 126
 127 int system_info_get_platform_name(system_info_key_e key, system_info_data_type_e data_type, void **value)
 128 {
 129         char *PLATFORM_NAME = NULL;
 130         char *name = NULL;
 131         char str[MAXBUFSIZE];
 132         char tmpStr[MAXBUFSIZE];
 133         int tmpStrlen = 0;
 134         int i = 0;
 135         FILE *info;
 136         extern char *strcasestr(const char *s, const char *find);
 137
 138         info = fopen(OS_RELEASE_FILE_PATH, "r");
 139         if (NULL == info) {
 140                 LOGE("cannot file open %s file!!!", OS_RELEASE_FILE_PATH);
 141                 return SYSTEM_INFO_ERROR_IO_ERROR;
 142         } else {
 143                 while (fgets(str, MAXBUFSIZE, info)) {
 144                         if (strcasestr(str, "NAME")) {
 145                                 name = strchr(str, '=');
 146                                 name += 2;
 147                                 tmpStrlen = strlen(name);
 148
 149                                 strncpy(tmpStr, name, tmpStrlen-2);
 150                                 tmpStr[tmpStrlen-2] = '\0';
 151
 152                                 tmpStrlen = strlen(tmpStr);
 153
 154                                 for (i = 0; i < tmpStrlen; i++)
 155                                                 tmpStr[i] = (char)toupper((int)tmpStr[i]);
 156
 157                                 PLATFORM_NAME = strdup(tmpStr);
 158                                 if (PLATFORM_NAME == NULL) {
 159                                         LOGE("OUT_OF_MEMORY(0x%08x)", SYSTEM_INFO_ERROR_OUT_OF_MEMORY);
 160                                         fclose(info);
 161                                         return SYSTEM_INFO_ERROR_OUT_OF_MEMORY;
 162                                 }
 163                                 break;
 164                         } else
 165                                 continue;
 166                 }
 167         }
 168         *value = PLATFORM_NAME;
 169         fclose(info);
 170         return SYSTEM_INFO_ERROR_NONE;
 171 }
 172
 173 int system_info_get_tizen_version_name(system_info_key_e key, system_info_data_type_e data_type, void **value)
 174 {
 175         char *TIZEN_VERSION_NAME = NULL;
 176         char *name = NULL;
 177         char str[MAXBUFSIZE];
 178         char tmpStr[MAXBUFSIZE];
 179         int tmpStrlen = 0;
 180         FILE *info;
 181         extern char *strcasestr(const char *s, const char *find);
 182
 183         info = fopen(OS_RELEASE_FILE_PATH, "r");
 184         if (NULL == info) {
 185                 LOGE("cannot file open %s file!!!", OS_RELEASE_FILE_PATH);
 186                 return SYSTEM_INFO_ERROR_IO_ERROR;
 187         } else {
 188                 while (fgets(str, MAXBUFSIZE, info)) {
 189                         if (strcasestr(str, "VERSION")) {
 190                                 name = strchr(str, ',');
 191                                 name += 2;
 192                                 tmpStrlen = strlen(name);
 193
 194                                 strncpy(tmpStr, name, tmpStrlen-2);
 195                                 tmpStr[tmpStrlen-2] = '\0';
 196
 197                                 TIZEN_VERSION_NAME = strdup(tmpStr);
 198                                 if (TIZEN_VERSION_NAME == NULL) {
 199                                         LOGE("OUT_OF_MEMORY(0x%08x)", SYSTEM_INFO_ERROR_OUT_OF_MEMORY);
 200                                         fclose(info);
 201                                         return SYSTEM_INFO_ERROR_OUT_OF_MEMORY;
 202                                 }
 203                                 break;
 204                         } else
 205                                 continue;
 206                 }
 207         }
 208         *value = TIZEN_VERSION_NAME;
 209         fclose(info);
 210         return SYSTEM_INFO_ERROR_NONE;
 211 }
 212
 213 int system_info_get_opengles_version(system_info_key_e key, system_info_data_type_e data_type, void **value)
 214 {
 215         char *version;
 216         char *OPENGLES_VERSION = NULL;
 217         int version_supported = 0;
 218
 219         if (!access(LIB_GLES_V1, R_OK))
 220                 version_supported += 1;
 221
 222         if (!access(LIB_GLES_V2, R_OK))
 223                 version_supported += 2;
 224
 225         switch (version_supported) {
 226         case 1:
 227                 version = "1.1";
 228                 break;
 229
 230         case 2:
 231                 version = "2.0";
 232                 break;
 233
 234         case 3:
 235                 version = "1.1/2.0";
 236                 break;
 237         default:
 238                 version = NULL;
 239                 break;
 240         }
 241
 242         if (version != NULL) {
 243                 OPENGLES_VERSION = strdup(version);
 244
 245                 if (OPENGLES_VERSION == NULL) {
 246                         LOGE("OUT_OF_MEMORY(0x%08x)", SYSTEM_INFO_ERROR_OUT_OF_MEMORY);
 247                         return SYSTEM_INFO_ERROR_OUT_OF_MEMORY;
 248                 }
 249         }
 250
 251         *value = OPENGLES_VERSION;
 252
 253         return SYSTEM_INFO_ERROR_NONE;
 254 }
 255
 256 int system_info_get_core_cpu_arch(system_info_key_e key, system_info_data_type_e data_type, void **value)
 257 {
 258         FILE *cpuinfo = NULL;
 259         char *CORE_CPU_ARCH = NULL;
 260         char *name = NULL;
 261         char str[MAXBUFSIZE] = "";
 262         char tmpStr[MAXBUFSIZE] = "";
 263
 264         cpuinfo = fopen(CPU_INFO_FILE_PATH, "r");
 265         if (NULL == cpuinfo) {
 266                 LOGE("cannot file open %s file!!!", CPU_INFO_FILE_PATH);
 267                 return SYSTEM_INFO_ERROR_IO_ERROR;
 268         } else {
 269                 while (fgets(str, MAXBUFSIZE, cpuinfo)) {
 270                         if (!strncmp("Processor", str, strlen("Processor"))) {
 271                                 name = strchr(str, ':');
 272                                 if (!(strncmp("ARMv7", name+2, strlen("ARMv7")))) {
 273                                         strncpy(tmpStr, name+2, strlen("ARMv7"));
 274                                         tmpStr[strlen("ARMv7")] = '\0';
 275                                 } else if (!(strncmp("ARMv6", name+2, strlen("ARMv6")))) {
 276                                         strncpy(tmpStr, name+2, strlen("ARMv6"));
 277                                         tmpStr[strlen("ARMv6")] = '\0';
 278                                 } else if (!(strncmp("x86", name+2, strlen("x86")))) {
 279                                         strncpy(tmpStr, name+2, strlen("x86"));
 280                                         tmpStr[strlen("x86")] = '\0';
 281                                 }
 282                         } else
 283                                 continue;
 284                 }
 285
 286                 /* x86 emulator doesn't have "Processor" field in /proc/cpuinfo */
 287                 if (strlen(tmpStr) == 0 && system_info_get_system_info_model_type() == SYSTEM_INFO_MODEL_TYPE_EMULATOR) {
 288                         strncpy(tmpStr, "x86", strlen("x86"));
 289                         tmpStr[strlen("x86")] = '\0';
 290                 } else if (strlen(tmpStr) == 0) {
 291                         strncpy(tmpStr, "Unkown", strlen("Unkown"));
 292                         tmpStr[strlen("Unkown")] = '\0';
 293                 }
 294
 295                 CORE_CPU_ARCH = strdup(tmpStr);
 296
 297                 if (CORE_CPU_ARCH == NULL) {
 298                         LOGE("OUT_OF_MEMORY(0x%08x)", SYSTEM_INFO_ERROR_OUT_OF_MEMORY);
 299                         fclose(cpuinfo);
 300                         return SYSTEM_INFO_ERROR_OUT_OF_MEMORY;
 301                 }
 302         }
 303         fclose(cpuinfo);
 304
 305         *value = CORE_CPU_ARCH;
 306
 307         return SYSTEM_INFO_ERROR_NONE;
 308 }
 309
 310 int system_info_get_core_fpu_arch(system_info_key_e key, system_info_data_type_e data_type, void **value)
 311 {
 312         FILE *cpuinfo = NULL;
 313         char *CORE_FPU_ARCH = NULL;
 314         char *name = NULL;
 315         char str[MAXBUFSIZE] = "";
 316         char tmpStr[MAXBUFSIZE] = "";
 317
 318         cpuinfo = fopen(CPU_INFO_FILE_PATH, "r");
 319         if (NULL == cpuinfo) {
 320                 LOGE("cannot file open %s file!!!", CPU_INFO_FILE_PATH);
 321                 return SYSTEM_INFO_ERROR_IO_ERROR;
 322         } else {
 323                 /* The target and the emulator uses the field "Features" and "flags" in /proc/cpuinfo */
 324                 if (system_info_get_system_info_model_type() != SYSTEM_INFO_MODEL_TYPE_EMULATOR)
 325                         snprintf(tmpStr, strlen("Features"), "Features");
 326                 else
 327                         snprintf(tmpStr, strlen("flags"), "flags");
 328
 329                 while (fgets(str, MAXBUFSIZE, cpuinfo)) {
 330                         if (!strncmp(tmpStr, str, strlen(tmpStr))) {
 331                                 name = strchr(str, ':');
 332                                 if (strstr(name+2, "vfpv3"))
 333                                         CORE_FPU_ARCH = strdup("vfpv3");
 334                                 else if (strstr(name+2, "vfpv2"))
 335                                         CORE_FPU_ARCH = strdup("vfpv2");
 336                                 else if (strstr(name+2, "ssse3"))
 337                                         CORE_FPU_ARCH = strdup("ssse3");
 338                                 else if (strstr(name+2, "sse3"))
 339                                         CORE_FPU_ARCH = strdup("sse3");
 340                                 else if (strstr(name+2, "sse2"))
 341                                         CORE_FPU_ARCH = strdup("sse2");
 342                                 else if (strstr(name+2, "sse"))
 343                                         CORE_FPU_ARCH = strdup("sse");
 344                                 else
 345                                         CORE_FPU_ARCH = strdup("Unkown");
 346
 347                                 if (CORE_FPU_ARCH == NULL) {
 348                                         LOGE("OUT_OF_MEMORY(0x%08x)", SYSTEM_INFO_ERROR_OUT_OF_MEMORY);
 349                                         fclose(cpuinfo);
 350                                         return SYSTEM_INFO_ERROR_OUT_OF_MEMORY;
 351                                 }
 352
 353                                 break;
 354                         } else
 355                                 continue;
 356                 }
 357         }
 358         fclose(cpuinfo);
 359
 360         *value = CORE_FPU_ARCH;
 361
 362         return SYSTEM_INFO_ERROR_NONE;
 363 }
 364
 365 int system_info_get_core_cpu_freq(system_info_key_e key, system_info_data_type_e data_type, void **value)
 366 {
 367         double *count;
 368         FILE *cpuinfo, *cpuinfo_max_freq;
 369         double max_freq = 0.0;
 370         char *name;
 371         char str[MAXBUFSIZE];
 372
 373         if (system_info_get_system_info_model_type() != SYSTEM_INFO_MODEL_TYPE_EMULATOR) {
 374                 cpuinfo_max_freq = fopen(CPU_INFO_MAX_FREQ_PATH, "r");
 375                 if (NULL == cpuinfo_max_freq) {
 376                         LOGE("cannot file open %s file!!!", CPU_INFO_MAX_FREQ_PATH);
 377                         return SYSTEM_INFO_ERROR_IO_ERROR;
 378                 } else {
 379                         if (fscanf(cpuinfo_max_freq, "%lf", &max_freq) < 1) {
 380                                 fclose(cpuinfo_max_freq);
 381                                 return SYSTEM_INFO_ERROR_IO_ERROR;
 382                         }
 383                         max_freq = max_freq / 1024;
 384                 }
 385                 fclose(cpuinfo_max_freq);
 386         } else {
 387                 /* Emulator */
 388                 cpuinfo = fopen(CPU_INFO_FILE_PATH, "r");
 389                 if (NULL == cpuinfo) {
 390                         LOGE("cannot file open %s file!!!", CPU_INFO_FILE_PATH);
 391                         return SYSTEM_INFO_ERROR_IO_ERROR;
 392                 } else {
 393                         while (fgets(str, MAXBUFSIZE, cpuinfo)) {
 394                                 if (!strncmp("cpu MHz", str, strlen("cpu MHz"))) {
 395                                         name = strchr(str, ':');
 396                                         max_freq = atof(name+2);
 397                                         break;
 398                                 }
 399                         }
 400                 }
 401                 fclose(cpuinfo);
 402         }
 403
 404         count = (double *)value;
 405
 406         *count = max_freq;
 407
 408         return SYSTEM_INFO_ERROR_NONE;
 409 }
 410
 411
 412 int system_info_get_opengles_texture_format(system_info_key_e key, system_info_data_type_e data_type, void **value)
 413 {
 414         char *OPENGLES_TEXTURE_FORMAT;
 415         char textureformat[MAXBUFSIZE];
 416
 417         textureformat[0] = '\0';
 418
 419         if (!access(LIB_GLES_V2, R_OK)) {
 420                 strcat(textureformat, "utc ");
 421         }
 422         if (GL_OES_compressed_paletted_texture) {
 423                 strcat(textureformat, "| ptc ");
 424         }
 425         if (GL_OES_compressed_ETC1_RGB8_texture) {
 426                 strcat(textureformat, "| etc ");
 427         }
 428         if (GL_AMD_compressed_3DC_texture) {
 429                 strcat(textureformat, "| 3dc ");
 430         }
 431         if (GL_AMD_compressed_ATC_texture) {
 432                 strcat(textureformat, "| atc ");
 433         }
 434         if (GL_IMG_texture_compression_pvrtc) {
 435                 strcat(textureformat, "| pvrtc");
 436         }
 437
 438         OPENGLES_TEXTURE_FORMAT = strdup(textureformat);
 439
 440         if (OPENGLES_TEXTURE_FORMAT == NULL) {
 441                 LOGE("OUT_OF_MEMORY(0x%08x)", SYSTEM_INFO_ERROR_OUT_OF_MEMORY);
 442                 return SYSTEM_INFO_ERROR_OUT_OF_MEMORY;
 443         }
 444
 445         *value = OPENGLES_TEXTURE_FORMAT;
 446
 447         return SYSTEM_INFO_ERROR_NONE;
 448 }
 449
 450 int system_info_get_build_string(system_info_key_e key, system_info_data_type_e data_type, void **value)
 451 {
 452         char *BUILD_STRING = NULL;
 453         char *name = NULL;
 454         char str[MAXBUFSIZE];
 455         char tmpStr[MAXBUFSIZE];
 456         FILE *info = NULL;
 457
 458         info = fopen(INFO_FILE_PATH, "r");
 459         if (NULL == info) {
 460                 LOGE("cannot file open %s file!!!", INFO_FILE_PATH);
 461                 return SYSTEM_INFO_ERROR_IO_ERROR;
 462         } else {
 463                 while (fgets(str, MAXBUFSIZE, info)) {
 464                         if (!strncmp("Build", str, strlen("Build"))) {
 465                                 name = strchr(str, '=');
 466                                 name++;
 467                                 strncpy(tmpStr, name, strlen(name)-2);
 468                                 tmpStr[strlen(name)-2] = '\0';
 469
 470                                 BUILD_STRING = strdup(tmpStr);
 471                                 if (BUILD_STRING == NULL) {
 472                                         LOGE("OUT_OF_MEMORY(0x%08x)", SYSTEM_INFO_ERROR_OUT_OF_MEMORY);
 473                                         fclose(info);
 474                                         return SYSTEM_INFO_ERROR_OUT_OF_MEMORY;
 475                                 }
 476                                 break;
 477                         } else
 478                                 continue;
 479                 }
 480         }
 481         *value = BUILD_STRING;
 482         fclose(info);
 483         return SYSTEM_INFO_ERROR_NONE;
 484 }
 485
 486 int system_info_get_build_date(system_info_key_e key, system_info_data_type_e data_type, void **value)
 487 {
 488         char *BUILD_DATE = NULL;
 489         char *name = NULL;
 490         char str[MAXBUFSIZE];
 491         char tmpStr[MAXBUFSIZE];
 492         FILE *info = NULL;
 493
 494         info = fopen(INFO_FILE_PATH, "r");
 495         if (NULL == info) {
 496                 LOGE("cannot file open %s file!!!", INFO_FILE_PATH);
 497                 return SYSTEM_INFO_ERROR_IO_ERROR;
 498         } else {
 499                 while (fgets(str, MAXBUFSIZE, info)) {
 500                         if (!strncmp("Date", str, strlen("Date"))) {
 501                                 name = strchr(str, '=');
 502                                 name++;
 503                                 strncpy(tmpStr, name, strlen(name)-2);
 504                                 tmpStr[strlen(name)-2] = '\0';
 505
 506                                 BUILD_DATE = strdup(tmpStr);
 507                                 if (BUILD_DATE == NULL) {
 508                                         LOGE("OUT_OF_MEMORY(0x%08x)", SYSTEM_INFO_ERROR_OUT_OF_MEMORY);
 509                                         fclose(info);
 510                                         return SYSTEM_INFO_ERROR_OUT_OF_MEMORY;
 511                                 }
 512                                 break;
 513                         } else
 514                                 continue;
 515                 }
 516         }
 517         *value = BUILD_DATE;
 518         fclose(info);
 519         return SYSTEM_INFO_ERROR_NONE;
 520 }
 521
 522 int system_info_get_build_time(system_info_key_e key, system_info_data_type_e data_type, void **value)
 523 {
 524         char *BUILD_TIME = NULL;
 525         char *name = NULL;
 526         char str[MAXBUFSIZE];
 527         char tmpStr[MAXBUFSIZE];
 528         FILE *info = NULL;
 529
 530         info = fopen(INFO_FILE_PATH, "r");
 531         if (NULL == info) {
 532                 LOGE("cannot file open %s file!!!", INFO_FILE_PATH);
 533                 return SYSTEM_INFO_ERROR_IO_ERROR;
 534         } else {
 535                 while (fgets(str, MAXBUFSIZE, info)) {
 536                         if (!strncmp("Time", str, strlen("Time"))) {
 537                                 name = strchr(str, '=');
 538                                 name++;
 539                                 strncpy(tmpStr, name, strlen(name)-2);
 540                                 tmpStr[strlen(name)-2] = '\0';
 541
 542                                 BUILD_TIME = strdup(tmpStr);
 543                                 if (BUILD_TIME == NULL) {
 544                                         LOGE("OUT_OF_MEMORY(0x%08x)", SYSTEM_INFO_ERROR_OUT_OF_MEMORY);
 545                                         fclose(info);
 546                                         return SYSTEM_INFO_ERROR_OUT_OF_MEMORY;
 547                                 }
 548                                 break;
 549                         } else
 550                                 continue;
 551                 }
 552         }
 553         *value = BUILD_TIME;
 554         fclose(info);
 555         return SYSTEM_INFO_ERROR_NONE;
 556 }