Home | History | Annotate | Download | only in utils 
      1 /*
      2  * Copyright (C) 2007 The Android Open Source Project
      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 #ifndef _LIBS_UTILS_ANDROID_THREADS_H
     18 #define _LIBS_UTILS_ANDROID_THREADS_H
     19 
     20 #include <stdint.h>
     21 #include <sys/types.h>
     22 
     23 #if !defined(_WIN32)
     24 # include <pthread.h>
     25 #endif
     26 
     27 #include <utils/ThreadDefs.h>
     28 
     29 // ---------------------------------------------------------------------------
     30 // C API
     31 
     32 #ifdef __cplusplus
     33 extern "C" {
     34 #endif
     35 
     36 // Create and run a new thread.
     37 extern int androidCreateThread(android_thread_func_t, void *);
     38 
     39 // Create thread with lots of parameters
     40 extern int androidCreateThreadEtc(android_thread_func_t entryFunction,
     41                                   void *userData,
     42                                   const char* threadName,
     43                                   int32_t threadPriority,
     44                                   size_t threadStackSize,
     45                                   android_thread_id_t *threadId);
     46 
     47 // Get some sort of unique identifier for the current thread.
     48 extern android_thread_id_t androidGetThreadId();
     49 
     50 // Low-level thread creation -- never creates threads that can
     51 // interact with the Java VM.
     52 extern int androidCreateRawThreadEtc(android_thread_func_t entryFunction,
     53                                      void *userData,
     54                                      const char* threadName,
     55                                      int32_t threadPriority,
     56                                      size_t threadStackSize,
     57                                      android_thread_id_t *threadId);
     58 
     59 // set the same of the running thread
     60 extern void androidSetThreadName(const char* name);
     61 
     62 // Used by the Java Runtime to control how threads are created, so that
     63 // they can be proper and lovely Java threads.
     64 typedef int (*android_create_thread_fn)(android_thread_func_t entryFunction,
     65                                         void *userData,
     66                                         const char* threadName,
     67                                         int32_t threadPriority,
     68                                         size_t threadStackSize,
     69                                         android_thread_id_t *threadId);
     70 
     71 extern void androidSetCreateThreadFunc(android_create_thread_fn func);
     72 
     73 // ------------------------------------------------------------------
     74 // Extra functions working with raw pids.
     75 
     76 #if defined(__ANDROID__)
     77 // Change the priority AND scheduling group of a particular thread.  The priority
     78 // should be one of the ANDROID_PRIORITY constants.  Returns INVALID_OPERATION
     79 // if the priority set failed, else another value if just the group set failed;
     80 // in either case errno is set.  Thread ID zero means current thread.
     81 extern int androidSetThreadPriority(pid_t tid, int prio);
     82 
     83 // Get the current priority of a particular thread. Returns one of the
     84 // ANDROID_PRIORITY constants or a negative result in case of error.
     85 extern int androidGetThreadPriority(pid_t tid);
     86 #endif
     87 
     88 #ifdef __cplusplus
     89 } // extern "C"
     90 #endif
     91 
     92 // ----------------------------------------------------------------------------
     93 // C++ API
     94 #ifdef __cplusplus
     95 namespace android {
     96 // ----------------------------------------------------------------------------
     97 
     98 // Create and run a new thread.
     99 inline bool createThread(thread_func_t f, void *a) {
    100     return androidCreateThread(f, a) ? true : false;
    101 }
    102 
    103 // Create thread with lots of parameters
    104 inline bool createThreadEtc(thread_func_t entryFunction,
    105                             void *userData,
    106                             const char* threadName = "android:unnamed_thread",
    107                             int32_t threadPriority = PRIORITY_DEFAULT,
    108                             size_t threadStackSize = 0,
    109                             thread_id_t *threadId = 0)
    110 {
    111     return androidCreateThreadEtc(entryFunction, userData, threadName,
    112         threadPriority, threadStackSize, threadId) ? true : false;
    113 }
    114 
    115 // Get some sort of unique identifier for the current thread.
    116 inline thread_id_t getThreadId() {
    117     return androidGetThreadId();
    118 }
    119 
    120 // ----------------------------------------------------------------------------
    121 }; // namespace android
    122 #endif  // __cplusplus
    123 // ----------------------------------------------------------------------------
    124 
    125 #endif // _LIBS_UTILS_ANDROID_THREADS_H
    126