2. 程式人生 > >Android Camera 通過V4L2與kernel driver的完整交互過程

Android Camera 通過V4L2與kernel driver的完整交互過程

阿新 • • 發佈：2017-06-08
initial length 詳細 eas handler use orien amp com

http://blog.chinaunix.net/uid-26215986-id-3552456.html

原文地址：Android Camera 通過V4L2與kernel driver的完整交互過程 作者：xinyuwuxian

Android Camera 通過V4L2與kernel driver的完整交互過程

之前在 Android Camera 的執行流程 http://blog.chinaunix.net/uid-26765074-id-3499537.html 這篇文章中已經詳細介紹了
Android Camera app到調用open打開camera 設備的完成過程，但是只是到此為止，並未對較底層的操作控制等做任何分析，
今天就要進入這個環節了
技術分享
技術分享
這裏就直接從open那個方法開始了，先說一下這個open是怎麽被調用的

實例化Camera Hal接口 hardware，hardware調用initialize()進入HAL層打開Camear驅動。
CameraHardwareInterface中initialize()定義在以下路徑:frameworks/base/services/camera/libcameraservice/CameraHardwareInterface.h

代碼如下：

status_t initialize(hw_module_t *module)
{
LOGI("Opening camera %s", mName.string());
int rc = module->methods->open(module, mName.string(),(hw_device_t **)&mDevice);
if (rc != OK) {
LOGE("Could not open camera %s: %d", mName.string(), rc);
return rc;
}
#ifdef OMAP_ENHANCEMENT_CPCAM
initHalPreviewWindow(&mHalPreviewWindow);
initHalPreviewWindow(&mHalTapin);
initHalPreviewWindow(&mHalTapout);
#else
initHalPreviewWindow();
#endif
return rc;
}
此處通過module->method->open()方法真正打開Camera設備,

其中module的定義在以下路徑:frameworks/base/services/camera/libcameraservice/CameraService.h

class CameraService :
public BinderService<CameraService>,
public BnCameraService
{

class Client : public BnCamera
{
public:
......

private:

.....

};

camera_module_t *mModule;

};

此處還必須找到camera_module_t 的定義,以更好的理解整個運行流程,通過追根溯源找到了camera_module_t 定義,

camera_module_t的定義在以下路徑:hardware/libhardware/include/hardware/camera.h

typedef struct camera_module {
hw_module_t common;
int (*get_number_of_cameras)(void);
int (*get_camera_info)(int camera_id, struct camera_info *info);
} camera_module_t;
其中包含get_number_of_cameras方法和get_camera_info方法用於獲取camera info

另外hw_module_t common;這個選項十分重要,此處應重點關註,因為是使用hw_module_t結構體中的open()方法打開設備文件的

繼續找到hw_module_t 結構體的定義.在以下路徑:hardware/libhardware/include/hardware/hardware.h

  1. typedef struct hw_module_t {
  2. /** tag must be initialized to HARDWARE_MODULE_TAG */
  3. uint32_t tag;
  5. /** major version number for the module */
  6. uint16_t version_major;
  8. /** minor version number of the module */
  9. uint16_t version_minor;
  11. /** Identifier of module */
  12. const char *id;
  14. /** Name of this module */
  15. const char *name;
  17. /** Author/owner/implementor of the module */
  18. const char *author;
  20. /** Modules methods */
  21. struct hw_module_methods_t* methods;
  23. /** module‘s dso */
  24. void* dso;
  26. /** padding to 128 bytes, reserved for future use */
  27. uint32_t reserved[32-7];
  29. } hw_module_t;
  1. typedef struct hw_module_methods_t {
  2. /** Open a specific device */
  3. int (*open)(const struct hw_module_t* module, const char* id,
  4. struct hw_device_t** device);
  6. } hw_module_methods_t;
這裏的這個open方法才是我們真正調用的open方法，那麽這裏只是定義，他又是在哪裏實現的呢？？
這個問題我們還是需要往前面追溯啊，當然這在上一篇文章中也沒有提到，不賣關子了，其實重點就是我們調用了這個module->methods->open(module, mName.string(),(hw_device_t **)&mDevice)方法
但是這個module是在哪裏初始化的呢？看看CameraService類裏的這個方法吧，路徑：frameworks/base/services/camera/libcameraservice/CameraService.cpp
  1. void CameraService::onFirstRef()
  2. {
  3. BnCameraService::onFirstRef();
  5. if (hw_get_module(CAMERA_HARDWARE_MODULE_ID,
  6. (const hw_module_t **)&mModule) < 0) {
  7. LOGE("Could not load camera HAL module");
  8. mNumberOfCameras = 0;
  9. }
  10. else {
  11. mNumberOfCameras = mModule->get_number_of_cameras();
  12. if (mNumberOfCameras > MAX_CAMERAS) {
  13. LOGE("Number of cameras(%d) > MAX_CAMERAS(%d).",
  14. mNumberOfCameras, MAX_CAMERAS);
  15. mNumberOfCameras = MAX_CAMERAS;
  16. }
  17. for (int i = 0; i < mNumberOfCameras; i++) {
  18. setCameraFree(i);
  19. }
  20. }
  21. }
不錯，這個module正是通過這個hw_get_module方法獲得的，其實他是通過方法中的CAMERA_HARDWARE_MODULE_ID作為flag最終找到已經定義好的module，那麽這個已經定義好的module又在哪呢，是什麽樣子的呢？
這裏我就直接放在這裏，不在拐彎抹角了，方法路徑：hardware/ti/omap4xxx/camera/CameraHal_Module.cpp
  1. static int camera_device_open(const hw_module_t* module, const char* name,
  2. hw_device_t** device);
  3. static int camera_device_close(hw_device_t* device);
  4. static int camera_get_number_of_cameras(void);
  5. static int camera_get_camera_info(int camera_id, struct camera_info *info);
  7. static struct hw_module_methods_t camera_module_methods = {
  8. open: camera_device_open
  9. };
  11. camera_module_t HAL_MODULE_INFO_SYM = {
  12. common: {
  13. tag: HARDWARE_MODULE_TAG,
  14. version_major: 1,
  15. version_minor: 0,
  16. id: CAMERA_HARDWARE_MODULE_ID,
  17. name: "TI OMAP CameraHal Module",
  18. author: "TI",
  19. methods: &camera_module_methods,
  20. dso: NULL, /* remove compilation warnings */
  21. reserved: {0}, /* remove compilation warnings */
  22. },
  23. get_number_of_cameras: camera_get_number_of_cameras,
  24. get_camera_info: camera_get_camera_info,
  25. };
這裏還是很關鍵的，通過id：CAMERA_HARDWARE_MODULE_ID作為識別碼找到這個module，get module完成任務，大家可以看到，這個定義好的module實現了methods中的open方法，
實現了camera_get_number_of_cameras和camera_get_camera_info，當然還包括了其他一些變量的初始化
這裏開始我們找到了我們真正需要的open方法，萬裏長征走完一大步了，現在就去看看這個open方法幹了些什麽吧
  1. /* open device handle to one of the cameras
  2. *
  3. * assume camera service will keep singleton of each camera
  4. * so this function will always only be called once per camera instance
  5. */
  7. int camera_device_open(const hw_module_t* module, const char* name,
  8. hw_device_t** device)
  9. {
  10. int rv = 0;
  11. int num_cameras = 0;
  12. int cameraid;
  13. ti_camera_device_t* camera_device = NULL;
  14. camera_device_ops_t* camera_ops = NULL;
  15. android::CameraHal* camera = NULL;
  16. android::CameraProperties::Properties* properties = NULL;
  18. android::Mutex::Autolock lock(gCameraHalDeviceLock);
  20. CAMHAL_LOGI("camera_device open");
  22. if (name != NULL) {
  23. cameraid = atoi(name);
  24. num_cameras = gCameraProperties.camerasSupported();
  26. if(cameraid > num_cameras)
  27. {
  28. LOGE("camera service provided cameraid out of bounds, "
  29. "cameraid = %d, num supported = %d",
  30. cameraid, num_cameras);
  31. rv = -EINVAL;
  32. goto fail;
  33. }
  35. if(gCamerasOpen >= MAX_SIMUL_CAMERAS_SUPPORTED)
  36. {
  37. LOGE("maximum number of cameras already open");
  38. rv = -ENOMEM;
  39. goto fail;
  40. }
  42. camera_device = (ti_camera_device_t*)malloc(sizeof(*camera_device));
  43. if(!camera_device)
  44. {
  45. LOGE("camera_device allocation fail");
  46. rv = -ENOMEM;
  47. goto fail;
  48. }
  50. camera_ops = (camera_device_ops_t*)malloc(sizeof(*camera_ops));
  51. if(!camera_ops)
  52. {
  53. LOGE("camera_ops allocation fail");
  54. rv = -ENOMEM;
  55. goto fail;
  56. }
  58. memset(camera_device, 0, sizeof(*camera_device));
  59. memset(camera_ops, 0, sizeof(*camera_ops));
  61. camera_device->base.common.tag = HARDWARE_DEVICE_TAG;
  62. camera_device->base.common.version = 0;
  63. camera_device->base.common.module = (hw_module_t *)(module);
  64. camera_device->base.common.close = camera_device_close;
  65. camera_device->base.ops = camera_ops;
  67. camera_ops->set_preview_window = camera_set_preview_window;
  68. #ifdef OMAP_ENHANCEMENT_CPCAM
  69. camera_ops->set_buffer_source = camera_set_buffer_source;
  70. #endif
  71. camera_ops->set_callbacks = camera_set_callbacks;
  72. camera_ops->enable_msg_type = camera_enable_msg_type;
  73. camera_ops->disable_msg_type = camera_disable_msg_type;
  74. camera_ops->msg_type_enabled = camera_msg_type_enabled;
  75. camera_ops->start_preview = camera_start_preview;
  76. camera_ops->stop_preview = camera_stop_preview;
  77. camera_ops->preview_enabled = camera_preview_enabled;
  78. camera_ops->store_meta_data_in_buffers = camera_store_meta_data_in_buffers;
  79. camera_ops->start_recording = camera_start_recording;
  80. camera_ops->stop_recording = camera_stop_recording;
  81. camera_ops->recording_enabled = camera_recording_enabled;
  82. camera_ops->release_recording_frame = camera_release_recording_frame;
  83. camera_ops->auto_focus = camera_auto_focus;
  84. camera_ops->cancel_auto_focus = camera_cancel_auto_focus;
  85. camera_ops->take_picture = camera_take_picture;
  86. camera_ops->cancel_picture = camera_cancel_picture;
  87. camera_ops->set_parameters = camera_set_parameters;
  88. camera_ops->get_parameters = camera_get_parameters;
  89. camera_ops->put_parameters = camera_put_parameters;
  90. camera_ops->send_command = camera_send_command;
  91. camera_ops->release = camera_release;
  92. camera_ops->dump = camera_dump;
  93. #ifdef OMAP_ENHANCEMENT_CPCAM
  94. camera_ops->reprocess = camera_reprocess;
  95. camera_ops->cancel_reprocess = camera_cancel_reprocess;
  96. #endif
  98. *device = &camera_device->base.common;
  100. // -------- TI specific stuff --------
  102. camera_device->cameraid = cameraid;
  104. if(gCameraProperties.getProperties(cameraid, &properties) < 0)
  105. {
  106. LOGE("Couldn‘t get camera properties");
  107. rv = -ENOMEM;
  108. goto fail;
  109. }
  111. camera = new android::CameraHal(cameraid);
  113. if(!camera)
  114. {
  115. LOGE("Couldn‘t create instance of CameraHal class");
  116. rv = -ENOMEM;
  117. goto fail;
  118. }
  120. if(properties && (camera->initialize(properties) != android::NO_ERROR))
  121. {
  122. LOGE("Couldn‘t initialize camera instance");
  123. rv = -ENODEV;
  124. goto fail;
  125. }
  127. gCameraHals[cameraid] = camera;
  128. gCamerasOpen++;
  129. }
  131. return rv;
  133. fail:
  134. if(camera_device) {
  135. free(camera_device);
  136. camera_device = NULL;
  137. }
  138. if(camera_ops) {
  139. free(camera_ops);
  140. camera_ops = NULL;
  141. }
  142. if(camera) {
  143. delete camera;
  144. camera = NULL;
  145. }
  146. *device = NULL;
  147. return rv;
  148. }
看看這麽長的代碼，open的任務還是比較中的，沒辦法，能者多勞嘛，紅色部分是最重點的部分
從這裏可以知道，這裏就像一個控制中心，上傳調用到這裏被分發出去，實現各自的操作，我們就以startPreview為例進行分析

  1. int camera_start_preview(struct camera_device * device)
  2. {
  3. int rv = -EINVAL;
  4. ti_camera_device_t* ti_dev = NULL;
  6. LOGV("%s", __FUNCTION__);
  8. if(!device)
  9. return rv;
  11. ti_dev = (ti_camera_device_t*) device;
  13. rv = gCameraHals[ti_dev->cameraid]->startPreview();
  15. return rv;
  16. }
這裏每open一個device就會相應的創建並且初始化一個CameraHal 對象，定義在：hardware/ti/omap4xxx/camera/CameraHal.cpp
並且把這個對象保存在gCameraHals這個數組中，正因為這樣這裏camera_start_preview才可以通過這個數據檢索對象調用方法
現在我們就看看這個startPreview()方法是怎樣實現的
  1. /**
  2. @brief Start preview mode.
  4. @param none
  5. @return NO_ERROR Camera switched to VF mode
  6. @todo Update function header with the different errors that are possible
  8. */
  9. status_t CameraHal::startPreview() {
  10. LOG_FUNCTION_NAME;
  12. // When tunneling is enabled during VTC, startPreview happens in 2 steps:
  13. // When the application sends the command CAMERA_CMD_PREVIEW_INITIALIZATION,
  14. // cameraPreviewInitialization() is called, which in turn causes the CameraAdapter
  15. // to move from loaded to idle state. And when the application calls startPreview,
  16. // the CameraAdapter moves from idle to executing state.
  17. //
  18. // If the application calls startPreview() without sending the command
  19. // CAMERA_CMD_PREVIEW_INITIALIZATION, then the function cameraPreviewInitialization()
  20. // AND startPreview() are executed. In other words, if the application calls
  21. // startPreview() without sending the command CAMERA_CMD_PREVIEW_INITIALIZATION,
  22. // then the CameraAdapter moves from loaded to idle to executing state in one shot.
  23. status_t ret = cameraPreviewInitialization();
  25. // The flag mPreviewInitializationDone is set to true at the end of the function
  26. // cameraPreviewInitialization(). Therefore, if everything goes alright, then the
  27. // flag will be set. Sometimes, the function cameraPreviewInitialization() may
  28. // return prematurely if all the resources are not available for starting preview.
  29. // For example, if the preview window is not set, then it would return NO_ERROR.
  30. // Under such circumstances, one should return from startPreview as well and should
  31. // not continue execution. That is why, we check the flag and not the return value.
  32. if (!mPreviewInitializationDone) return ret;
  34. // Once startPreview is called, there is no need to continue to remember whether
  35. // the function cameraPreviewInitialization() was called earlier or not. And so
  36. // the flag mPreviewInitializationDone is reset here. Plus, this preserves the
  37. // current behavior of startPreview under the circumstances where the application
  38. // calls startPreview twice or more.
  39. mPreviewInitializationDone = false;
  41. ///Enable the display adapter if present, actual overlay enable happens when we post the buffer
  42. if(mDisplayAdapter.get() != NULL) {
  43. CAMHAL_LOGDA("Enabling display");
  44. int width, height;
  45. mParameters.getPreviewSize(&width, &height);
  47. #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
  48. ret = mDisplayAdapter->enableDisplay(width, height, &mStartPreview);
  49. #else
  50. ret = mDisplayAdapter->enableDisplay(width, height, NULL);
  51. #endif
  53. if ( ret != NO_ERROR ) {
  54. CAMHAL_LOGEA("Couldn‘t enable display");
  56. // FIXME: At this stage mStateSwitchLock is locked and unlock is supposed to be called
  57. // only from mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_PREVIEW)
  58. // below. But this will never happen because of goto error. Thus at next
  59. // startPreview() call CameraHAL will be deadlocked.
  60. // Need to revisit mStateSwitch lock, for now just abort the process.
  61. CAMHAL_ASSERT_X(false,
  62. "At this stage mCameraAdapter->mStateSwitchLock is still locked, "
  63. "deadlock is guaranteed");
  65. goto error;
  66. }
  68. }
  70. ///Send START_PREVIEW command to adapter
  71. CAMHAL_LOGDA("Starting CameraAdapter preview mode");
  73. ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_PREVIEW);
  75. if(ret!=NO_ERROR) {
  76. CAMHAL_LOGEA("Couldn‘t start preview w/ CameraAdapter");
  77. goto error;
  78. }
  79. CAMHAL_LOGDA("Started preview");
  81. mPreviewEnabled = true;
  82. mPreviewStartInProgress = false;
  83. return ret;
  85. error:
  87. CAMHAL_LOGEA("Performing cleanup after error");
  89. //Do all the cleanup
  90. freePreviewBufs();
  91. mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_PREVIEW);
  92. if(mDisplayAdapter.get() != NULL) {
  93. mDisplayAdapter->disableDisplay(false);
  94. }
  95. mAppCallbackNotifier->stop();
  96. mPreviewStartInProgress = false;
  97. mPreviewEnabled = false;
  98. LOG_FUNCTION_NAME_EXIT;
  100. return ret;
  101. }
在我的理解看來上面標註的部分是這個方法的關鍵，這個地方可是會讓初次研究這裏的人暈頭轉向的，因為我就在這裏犯了錯誤，走岔道了，下面會說明到底是怎麽走岔道的：
先說一下吧，這裏調用mCameraAdapter對象的sendCommand方法

  1. status_t BaseCameraAdapter::sendCommand(CameraCommands operation, int value1, int value2, int value3, int value4) {
  2. status_t ret = NO_ERROR;
  3. struct timeval *refTimestamp;
  4. BuffersDescriptor *desc = NULL;
  5. CameraFrame *frame = NULL;
  7. LOG_FUNCTION_NAME;
  9. switch ( operation ) {
  10. case：
  11. ...............
  12. case CameraAdapter::CAMERA_START_PREVIEW:
    {
    CAMHAL_LOGDA("Start Preview");
    if ( ret == NO_ERROR )
    {
    ret = setState(operation);
    }

    if ( ret == NO_ERROR )
    {
    ret = startPreview();
    }

    if ( ret == NO_ERROR )
    {
    ret = commitState();
    }else{
    ret |= rollbackState();
    }
    break;
    }
  13. }
  14. }
  1. status_t BaseCameraAdapter::setState(CameraCommands operation)
  2. {
  3. status_t ret = NO_ERROR;
  5. LOG_FUNCTION_NAME;
  7. const char *printState = getLUTvalue_translateHAL(operation, CamCommandsLUT);
  9. mLock.lock();
  11. switch ( mAdapterState )
  12. {
  14. case INTIALIZED_STATE:
  15. ............
  17. case LOADED_PREVIEW_STATE:
  19. switch ( operation )
  20. {
  22. case CAMERA_START_PREVIEW:
  23. CAMHAL_LOGDB("Adapter state switch LOADED_PREVIEW_STATE->PREVIEW_STATE event = %s",
  24. printState);
  25. mNextState = PREVIEW_STATE;
  26. break;
  27. }
  28. }
  29. }
  1. status_t BaseCameraAdapter::startPreview()
  2. {
  3. status_t ret = NO_ERROR;
  5. LOG_FUNCTION_NAME;
  7. LOG_FUNCTION_NAME_EXIT;
  9. return ret;
  10. }
就是這裏了，所以我用可很醒目的顏色標註出來，很多人會想當然的理解，你不是調用了startPreview方法嘛，那就是他了啊！可是這裏為什麽什麽動作都沒做呢？？
於是就卡在這裏不知所措了，那個糾結啊技術分享技術分享
現在就來解開這個謎團吧！！！

這個我們還是要往前追溯了，追溯到哪裏呢？？那就從這裏開始吧
mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_PREVIEW);
這個方式是在CameraHal的startPreview() 方法中被調用的
所以我要知道這個mCameraAdapter對象原型是什麽啊，他從哪裏而來，原來他是CameraHal這個類的一個成員，定義在：hardware/ti/omap4xxx/camera/inc/CameraHal.h
CameraAdapter *mCameraAdapter;
這裏必須打破砂鍋追到底，找到CameraAdapter 這個類的定義，他的定義同樣這這個.h文件中

  1. /**
  2. * CameraAdapter interface class
  3. * Concrete classes derive from this class and provide implementations based on the specific camera h/w interface
  4. */
  6. class CameraAdapter: public FrameNotifier, public virtual RefBase
  7. {
  8. protected:
  9. enum AdapterActiveStates {
  10. INTIALIZED_ACTIVE = 1 << 0,
  11. LOADED_PREVIEW_ACTIVE = 1 << 1,
  12. PREVIEW_ACTIVE = 1 << 2,
  13. LOADED_CAPTURE_ACTIVE = 1 << 3,
  14. CAPTURE_ACTIVE = 1 << 4,
  15. BRACKETING_ACTIVE = 1 << 5,
  16. AF_ACTIVE = 1 << 6,
  17. ZOOM_ACTIVE = 1 << 7,
  18. VIDEO_ACTIVE = 1 << 8,
  19. LOADED_REPROCESS_ACTIVE = 1 << 9,
  20. REPROCESS_ACTIVE = 1 << 10,
  21. };
  22. public:
  23. typedef struct
  24. {
  25. CameraBuffer *mBuffers;
  26. uint32_t *mOffsets;
  27. int mFd;
  28. size_t mLength;
  29. size_t mCount;
  30. size_t mMaxQueueable;
  31. } BuffersDescriptor;
  33. enum CameraCommands
  34. {
  35. CAMERA_START_PREVIEW = 0,
  36. CAMERA_STOP_PREVIEW = 1,
  37. CAMERA_START_VIDEO = 2,
  38. CAMERA_STOP_VIDEO = 3,
  39. CAMERA_START_IMAGE_CAPTURE = 4,
  40. CAMERA_STOP_IMAGE_CAPTURE = 5,
  41. CAMERA_PERFORM_AUTOFOCUS = 6,
  42. CAMERA_CANCEL_AUTOFOCUS = 7,
  43. CAMERA_PREVIEW_FLUSH_BUFFERS = 8,
  44. CAMERA_START_SMOOTH_ZOOM = 9,
  45. CAMERA_STOP_SMOOTH_ZOOM = 10,
  46. CAMERA_USE_BUFFERS_PREVIEW = 11,
  47. CAMERA_SET_TIMEOUT = 12,
  48. CAMERA_CANCEL_TIMEOUT = 13,
  49. CAMERA_START_BRACKET_CAPTURE = 14,
  50. CAMERA_STOP_BRACKET_CAPTURE = 15,
  51. CAMERA_QUERY_RESOLUTION_PREVIEW = 16,
  52. CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE = 17,
  53. CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA = 18,
  54. CAMERA_USE_BUFFERS_IMAGE_CAPTURE = 19,
  55. CAMERA_USE_BUFFERS_PREVIEW_DATA = 20,
  56. CAMERA_TIMEOUT_EXPIRED = 21,
  57. CAMERA_START_FD = 22,
  58. CAMERA_STOP_FD = 23,
  59. CAMERA_SWITCH_TO_EXECUTING = 24,
  60. CAMERA_USE_BUFFERS_VIDEO_CAPTURE = 25,
  61. #ifdef OMAP_ENHANCEMENT_CPCAM
  62. CAMERA_USE_BUFFERS_REPROCESS = 26,
  63. CAMERA_START_REPROCESS = 27,
  64. #endif
  65. #ifdef OMAP_ENHANCEMENT_VTC
  66. CAMERA_SETUP_TUNNEL = 28,
  67. CAMERA_DESTROY_TUNNEL = 29,
  68. #endif
  69. CAMERA_PREVIEW_INITIALIZATION = 30,
  70. };
  72. enum CameraMode
  73. {
  74. CAMERA_PREVIEW,
  75. CAMERA_IMAGE_CAPTURE,
  76. CAMERA_VIDEO,
  77. CAMERA_MEASUREMENT,
  78. CAMERA_REPROCESS,
  79. };
  81. enum AdapterState {
  82. INTIALIZED_STATE = INTIALIZED_ACTIVE,
  83. LOADED_PREVIEW_STATE = LOADED_PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  84. PREVIEW_STATE = PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  85. LOADED_CAPTURE_STATE = LOADED_CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  86. CAPTURE_STATE = CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  87. BRACKETING_STATE = BRACKETING_ACTIVE | CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE ,
  88. AF_STATE = AF_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  89. ZOOM_STATE = ZOOM_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  90. VIDEO_STATE = VIDEO_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  91. VIDEO_AF_STATE = VIDEO_ACTIVE | AF_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  92. VIDEO_ZOOM_STATE = VIDEO_ACTIVE | ZOOM_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  93. VIDEO_LOADED_CAPTURE_STATE = VIDEO_ACTIVE | LOADED_CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  94. VIDEO_CAPTURE_STATE = VIDEO_ACTIVE | CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  95. AF_ZOOM_STATE = AF_ACTIVE | ZOOM_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  96. BRACKETING_ZOOM_STATE = BRACKETING_ACTIVE | ZOOM_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  97. LOADED_REPROCESS_STATE = LOADED_REPROCESS_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  98. LOADED_REPROCESS_CAPTURE_STATE = LOADED_REPROCESS_ACTIVE | LOADED_CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  99. REPROCESS_STATE = REPROCESS_ACTIVE | CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
  100. };
  103. public:
  105. ///Initialzes the camera adapter creates any resources required
  106. virtual int initialize(CameraProperties::Properties*) = 0;
  108. virtual int setErrorHandler(ErrorNotifier *errorNotifier) = 0;
  110. //Message/Frame notification APIs
  111. virtual void enableMsgType(int32_t msgs,
  112. frame_callback callback = NULL,
  113. event_callback eventCb = NULL,
  114. void *cookie = NULL) = 0;
  115. virtual void disableMsgType(int32_t msgs, void* cookie) = 0;
  116. virtual void returnFrame(CameraBuffer* frameBuf, CameraFrame::FrameType frameType) = 0;
  117. virtual void addFramePointers(CameraBuffer *frameBuf, void *buf) = 0;
  118. virtual void removeFramePointers() = 0;
  120. //APIs to configure Camera adapter and get the current parameter set
  121. virtual int setParameters(const CameraParameters& params) = 0;
  122. virtual void getParameters(CameraParameters& params) = 0;
  124. //Registers callback for returning image buffers back to CameraHAL
  125. virtual int registerImageReleaseCallback(release_image_buffers_callback callback, void *user_data) = 0;
  127. //Registers callback, which signals a completed image capture
  128. virtual int registerEndCaptureCallback(end_image_capture_callback callback, void *user_data) = 0;
  130. //API to send a command to the camera
  131. virtual status_t sendCommand(CameraCommands operation, int value1=0, int value2=0, int value3=0, int value4=0) = 0;
  133. virtual ~CameraAdapter() {};
  135. //Retrieves the current Adapter state
  136. virtual AdapterState getState() = 0;
  138. //Retrieves the next Adapter state
  139. virtual AdapterState getNextState() = 0;
  141. // Receive orientation events from CameraHal
  142. virtual void onOrientationEvent(uint32_t orientation, uint32_t tilt) = 0;
  144. // Rolls the state machine back to INTIALIZED_STATE from the current state
  145. virtual status_t rollbackToInitializedState() = 0;
  147. // Retrieves the current Adapter state - for internal use (not locked)
  148. virtual status_t getState(AdapterState &state) = 0;
  149. // Retrieves the next Adapter state - for internal use (not locked)
  150. virtual status_t getNextState(AdapterState &state) = 0;
  152. protected:
  153. //The first two methods will try to switch the adapter state.
  154. //Every call to setState() should be followed by a corresponding
  155. //call to commitState(). If the state switch fails, then it will
  156. //get reset to the previous state via rollbackState().
  157. virtual status_t setState(CameraCommands operation) = 0;
  158. virtual status_t commitState() = 0;
  159. virtual status_t rollbackState() = 0;
  160. };
看一下我標出的這是紅色部分啊，為什麽我要把它們標註成紅色呢？？
懂C++面向對象思想應該都知道virtual這個關鍵字是幹什麽的，
如果一個類的方法被定義為virtual，如果該類的子類實現了同樣的方法，則這個方法被調用的時候，會忽略父類的實現，而直接調用子類的實現，前提是方法名，包括變量類型，個數必須一致
那麽這裏有沒有類繼承了CameraAdapter 這個類，並且實現了其中的一些虛擬函數呢？？答案是肯定的，我可是吃了苦頭才發現的技術分享技術分享
不過也是賴自己，這是只有定義是沒有實現的，肯定是由子類來實現這是方法的，不，還是不賴自己，讓我吃苦頭的是這裏是雙層繼承的，雙層繼承啊，我怎麽知道技術分享技術分享
不賣關子了，那麽誰繼承了CameraAdapter 這個類呢？ 先給路徑：hardware/ti/omap4xxx/camera/inc/BaseCameraAdapter.h

  1. class BaseCameraAdapter : public CameraAdapter
  2. {
  4. public:
  6. BaseCameraAdapter();
  7. virtual ~BaseCameraAdapter();
  9. ///Initialzes the camera adapter creates any resources required
  10. virtual status_t initialize(CameraProperties::Properties*) = 0;
  12. virtual int setErrorHandler(ErrorNotifier *errorNotifier);
  14. //Message/Frame notification APIs
  15. virtual void enableMsgType(int32_t msgs, frame_callback callback=NULL, event_callback eventCb=NULL, void* cookie=NULL);
  16. virtual void disableMsgType(int32_t msgs, void* cookie);
  17. virtual void returnFrame(CameraBuffer * frameBuf, CameraFrame::FrameType frameType);
  18. virtual void addFramePointers(CameraBuffer *frameBuf, void *y_uv);
  19. virtual void removeFramePointers();
  21. //APIs to configure Camera adapter and get the current parameter set
  22. virtual status_t setParameters(const CameraParameters& params) = 0;
  23. virtual void getParameters(CameraParameters& params) = 0;
  25. //API to send a command to the camera
  26. virtual status_t sendCommand(CameraCommands operation, int value1 = 0, int value2 = 0, int value3 = 0, int value4 = 0 );
  28. virtual status_t registerImageReleaseCallback(release_image_buffers_callback callback, void *user_data);
  30. virtual status_t registerEndCaptureCallback(end_image_capture_callback callback, void *user_data);
  32. //Retrieves the current Adapter state
  33. virtual AdapterState getState();
  34. //Retrieves the next Adapter state
  35. virtual AdapterState getNextState();
  37. // Rolls the state machine back to INTIALIZED_STATE from the current state
  38. virtual status_t rollbackToInitializedState();
  40. protected:
  41. //The first two methods will try to switch the adapter state.
  42. //Every call to setState() should be followed by a corresponding
  43. //call to commitState(). If the state switch fails, then it will
  44. //get reset to the previous state via rollbackState().
  45. virtual status_t setState(CameraCommands operation);
  46. virtual status_t commitState();
  47. virtual status_t rollbackState();
  49. // Retrieves the current Adapter state - for internal use (not locked)
  50. virtual status_t getState(AdapterState &state);
  51. // Retrieves the next Adapter state - for internal use (not locked)
  52. virtual status_t getNextState(AdapterState &state);
  54. //-----------Interface that needs to be implemented by deriving classes --------------------
  56. //Should be implmented by deriving classes in order to start image capture
  57. virtual status_t takePicture();
  59. //Should be implmented by deriving classes in order to start image capture
  60. virtual status_t stopImageCapture();
  62. //Should be implmented by deriving classes in order to start temporal bracketing
  63. virtual status_t startBracketing(int range);
  65. //Should be implemented by deriving classes in order to stop temporal bracketing
  66. virtual status_t stopBracketing();
  68. //Should be implemented by deriving classes in oder to initiate autoFocus
  69. virtual status_t autoFocus();
  71. //Should be implemented by deriving classes in oder to initiate autoFocus
  72. virtual status_t cancelAutoFocus();
  74. //Should be called by deriving classes in order to do some bookkeeping
  75. virtual status_t startVideoCapture();
  77. //Should be called by deriving classes in order to do some bookkeeping
  78. virtual status_t stopVideoCapture();
  80. //Should be implemented by deriving classes in order to start camera preview
  81. virtual status_t startPreview();
  83. //Should be implemented by deriving classes in order to stop camera preview
  84. virtual status_t stopPreview();
  86. //Should be implemented by deriving classes in order to start smooth zoom
  87. virtual status_t startSmoothZoom(int targetIdx);
  89. //Should be implemented by deriving classes in order to stop smooth zoom
  90. virtual status_t stopSmoothZoom();
  92. //Should be implemented by deriving classes in order to stop smooth zoom
  93. virtual status_t useBuffers(CameraMode mode, CameraBuffer* bufArr, int num, size_t length, unsigned int queueable);
  95. //Should be implemented by deriving classes in order queue a released buffer in CameraAdapter
  96. virtual status_t fillThisBuffer(CameraBuffer* frameBuf, CameraFrame::FrameType frameType);
  98. //API to get the frame size required to be allocated. This size is used to override the size passed
  99. //by camera service when VSTAB/VNF is turned ON for example
  100. virtual status_t getFrameSize(size_t &width, size_t &height);
  102. //API to get required data frame size
  103. virtual status_t getFrameDataSize(size_t &dataFrameSize, size_t bufferCount);
  105. //API to get required picture buffers size with the current configuration in CameraParameters
  106. virtual status_t getPictureBufferSize(size_t &length, size_t bufferCount);
  108. // Should be implemented by deriving classes in order to start face detection
  109. // ( if supported )
  110. virtual status_t startFaceDetection();
  112. // Should be implemented by deriving classes in order to stop face detection
  113. // ( if supported )
  114. virtual status_t stopFaceDetection();
  116. virtual status_t switchToExecuting();
  118. virtual status_t setupTunnel(uint32_t SliceHeight, uint32_t EncoderHandle, uint32_t width, uint32_t height);
  120. virtual status_t destroyTunnel();
  122. virtual status_t cameraPreviewInitialization();
  124. // Receive orientation events from CameraHal
  125. virtual void onOrientationEvent(uint32_t orientation, uint32_t tilt);
  127. // ---------------------Interface ends-----------------------------------
  129. status_t notifyFocusSubscribers(CameraHalEvent::FocusStatus status);
  130. status_t notifyShutterSubscribers();
  131. status_t notifyZoomSubscribers(int zoomIdx, bool targetReached);
  132. status_t notifyMetadataSubscribers(sp<CameraMetadataResult> &meta);
  134. //Send the frame to subscribers
  135. status_t sendFrameToSubscribers(CameraFrame *frame);
  137. //Resets the refCount for this particular frame
  138. status_t resetFrameRefCount(CameraFrame &frame);
  140. //A couple of helper functions
  141. void setFrameRefCount(CameraBuffer* frameBuf, CameraFrame::FrameType frameType, int refCount);
  142. int getFrameRefCount(CameraBuffer* frameBuf, CameraFrame::FrameType frameType);
  143. int setInitFrameRefCount(CameraBuffer* buf, unsigned int mask);
  144. static const char* getLUTvalue_translateHAL(int Value, LUTtypeHAL LUT);
  146. .................
  147. .................
  148. }
這裏我只列出了一部分代碼，不過大家清楚了，BaseCameraAdapter 繼承CameraAdapter，不過這裏還沒完呢，看看這個類中定義的方法
那麽多的virtual 方法，後來自己才發現的，他還是被別的類繼承了，而且其中的很多方法被子類重新實現了
所以實現上上面調用的startPreview方法其實不是BaseCameraAdapter.cpp中實現的那個startPreview方法
那挺調用的startPreview方法在哪裏呢，自然是繼承了BaseCameraAdapter 類的那個子類實現的startPreview
現在就把這個罪魁禍首拉上來，先看定義：hardware/ti/omap4xxx/camera/inc/V4LCameraAdapter/V4LCameraAdapter.h

  1. /**
  2. * Class which completely abstracts the camera hardware interaction from camera hal
  3. * TODO: Need to list down here, all the message types that will be supported by this class
  4. Need to implement BufferProvider interface to use AllocateBuffer of OMX if needed
  5. */
  6. class V4LCameraAdapter : public BaseCameraAdapter
  7. {
  8. public:
  10. /*--------------------Constant declarations----------------------------------------*/
  11. static const int32_t MAX_NO_BUFFERS = 20;
  13. [email protected] OMX Camera has six ports - buffer input, time input, preview, image, video, and meta data
  14. static const int MAX_NO_PORTS = 6;
  16. ///Five second timeout
  17. static const int CAMERA_ADAPTER_TIMEOUT = 5000*1000;
  19. public:
  21. V4LCameraAdapter(size_t sensor_index);
  22. ~V4LCameraAdapter();
  25. ///Initialzes the camera adapter creates any resources required
  26. virtual status_t initialize(CameraProperties::Properties*);
  28. //APIs to configure Camera adapter and get the current parameter set
  29. virtual status_t setParameters(const CameraParameters& params);
  30. virtual void getParameters(CameraParameters& params);
  32. // API
  33. virtual status_t UseBuffersPreview(CameraBuffer *bufArr, int num);
  34. virtual status_t UseBuffersCapture(CameraBuffer *bufArr, int num);
  36. static status_t getCaps(const int sensorId, CameraProperties::Properties* params, V4L_HANDLETYPE handle);
  38. protected:
  40. //----------Parent class method implementation------------------------------------//看看人家這裏說的很清楚，這是父類的方法
  41. virtual status_t startPreview();
  42. virtual status_t stopPreview();
  43. virtual status_t takePicture();
  44. virtual status_t stopImageCapture();
  45. virtual status_t autoFocus();
  46. virtual status_t useBuffers(CameraMode mode, CameraBuffer *bufArr, int num, size_t length, unsigned int queueable);
  47. virtual status_t fillThisBuffer(CameraBuffer *frameBuf, CameraFrame::FrameType frameType);
  48. virtual status_t getFrameSize(size_t &width, size_t &height);
  49. virtual status_t getPictureBufferSize(size_t &length, size_t bufferCount);
  50. virtual status_t getFrameDataSize(size_t &dataFrameSize, size_t bufferCount);
  51. virtual void onOrientationEvent(uint32_t orientation, uint32_t tilt);
  52. //-----------------------------------------------------------------------------
  55. private:
  57. class PreviewThread : public Thread {
  58. V4LCameraAdapter* mAdapter;
  59. public:
  60. PreviewThread(V4LCameraAdapter* hw) :
  61. Thread(false), mAdapter(hw) { }
  62. virtual void onFirstRef() {
  63. run("CameraPreviewThread", PRIORITY_URGENT_DISPLAY);
  64. }
  65. virtual bool threadLoop() {
  66. mAdapter->previewThread();
  67. // loop until we need to quit
  68. return true;
  69. }
  70. };
  72. //Used for calculation of the average frame rate during preview
  73. status_t recalculateFPS();
  75. char * GetFrame(int &index);
  77. int previewThread();
  79. public:
  81. private:
  82. //capabilities data
  83. static const CapPixelformat mPixelformats [];
  84. static const CapResolution mPreviewRes [];
  85. static const CapFramerate mFramerates [];
  86. static const CapResolution mImageCapRes [];
  88. //camera defaults
  89. static const char DEFAULT_PREVIEW_FORMAT[];
  90. static const char DEFAULT_PREVIEW_SIZE[];
  91. static const char DEFAULT_FRAMERATE[];
  92. static const char DEFAULT_NUM_PREV_BUFS[];
  94. static const char DEFAULT_PICTURE_FORMAT[];
  95. static const char DEFAULT_PICTURE_SIZE[];
  96. static const char DEFAULT_FOCUS_MODE[];
  97. static const char * DEFAULT_VSTAB;
  98. static const char * DEFAULT_VNF;
  100. static status_t insertDefaults(CameraProperties::Properties*, V4L_TI_CAPTYPE&);
  101. static status_t insertCapabilities(CameraProperties::Properties*, V4L_TI_CAPTYPE&);
  102. static status_t insertPreviewFormats(CameraProperties::Properties* , V4L_TI_CAPTYPE&);
  103. static status_t insertPreviewSizes(CameraProperties::Properties* , V4L_TI_CAPTYPE&);
  104. static status_t insertImageSizes(CameraProperties::Properties* , V4L_TI_CAPTYPE&);
  105. static status_t insertFrameRates(CameraProperties::Properties* , V4L_TI_CAPTYPE&);
  106. static status_t sortAscend(V4L_TI_CAPTYPE&, uint16_t ) ;
  108. status_t v4lIoctl(int, int, void*);
  109. status_t v4lInitMmap(int&);
  110. status_t v4lInitUsrPtr(int&);
  111. status_t v4lStartStreaming();
  112. status_t v4lStopStreaming(int nBufferCount);
  113. status_t v4lSetFormat(int, int, uint32_t);
  114. status_t restartPreview();
  117. int mPreviewBufferCount;
  118. int mPreviewBufferCountQueueable;
  119. int mCaptureBufferCount;
  120. int mCaptureBufferCountQueueable;
  121. KeyedVector<CameraBuffer *, int> mPreviewBufs;
  122. KeyedVector<CameraBuffer *, int> mCaptureBufs;
  123. mutable Mutex mPreviewBufsLock;
  124. mutable Mutex mCaptureBufsLock;
  125. mutable Mutex mStopPreviewLock;
  127. CameraParameters mParams;
  129. bool mPreviewing;
  130. bool mCapturing;
  131. Mutex mLock;
  133. int mFrameCount;
  134. int mLastFrameCount;
  135. unsigned int mIter;
  136. nsecs_t mLastFPSTime;
  138. //variables holding the estimated framerate
  139. float mFPS, mLastFPS;
  141. int mSensorIndex;
  143. // protected by mLoc
大家看到了V4LCameraAdapter 又繼承了BaseCameraAdapter，雙層繼承，實現了父類的一些方法
所有這裏算是媳婦熬著婆了，終於找到了我們想要的startPreview
不過看到終於進入了V4LCameraAdapter 這個類，我知道，離成功已經很近了，V4L2就是直接去和driver談判的
那麽我們就看看V4LCameraAdapter 這個類中的startPreview方法吧，路徑：ardware/ti/omap4xxx/camera/V4LCameraAdapter/V4LCameraAdapter.cpp

  1. status_t V4LCameraAdapter::startPreview()
  2. {
  3. status_t ret = NO_ERROR;
  5. LOG_FUNCTION_NAME;
  6. Mutex::Autolock lock(mPreviewBufsLock);
  8. if(mPreviewing) {
  9. ret = BAD_VALUE;
  10. goto EXIT;
  11. }
  13. for (int i = 0; i < mPreviewBufferCountQueueable; i++) {
  15. mVideoInfo->buf.index = i;
  16. mVideoInfo->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  17. mVideoInfo->buf.memory = V4L2_MEMORY_MMAP;
  19. ret = v4lIoctl(mCameraHandle, VIDIOC_QBUF, &mVideoInfo->buf);
  20. if (ret < 0) {
  21. CAMHAL_LOGEA("VIDIOC_QBUF Failed");
  22. goto EXIT;
  23. }
  24. nQueued++;
  25. }
  27. ret = v4lStartStreaming();
  29. // Create and start preview thread for receiving buffers from V4L Camera
  30. if(!mCapturing) {
  31. mPreviewThread = new PreviewThread(this);
  32. CAMHAL_LOGDA("Created preview thread");
  33. }
不錯，這條語句就是我一直找尋的，真是眾裏尋他千百度，驀然回首，那句就在燈火闌珊處
這樣，其他的事情就全部由v4l2去做了，這些過程會單獨分一章去學習
還有就是上面綠的部分，同樣要分一章學習，很重要

待續。。。。。。。。。。。

Android Camera 通過V4L2與kernel driver的完整交互過程

相關推薦

Android Camera 通過V4L2與kernel driver的完整交互過程

initial length 詳細 eas handler use orien amp com http://blog.chinaunix.net/uid-26215986-id-3552456.html 原文地址：Android Camera 通過V4L2與kernel

HTTPS協議，SSL協議及完整交互過程

對稱 secure 算法 sdn b2c 以及 網站 客戶端請求 交換 轉自：https://blog.csdn.net/dfsaggsd/article/details/50910999 SSL 1. 安全套接字（Secure Socket Layer，SS

Android Camera使用總結與那些坑

寫在開頭 需求方：上傳試卷的時候，使用者自己拍的照片有很多問題。如：不清晰、圖片歪了、錯誤圖片等。我們要是能夠對拍攝照片進行識別處理就好了，能夠裁切矯正就更好了，最好可以像二維碼掃描一樣，直接識別處理～ 開發：滿足你！ 整體框架邏輯 試卷掃描模組

Android手機通過Wifi與PC機之間進行通訊問題 （有程式碼）

這個一個手機客戶端的程式，伺服器程式在PC上。手機和電腦處於同一個區域網內，現在的問題是我摁下發送按鈕 PC上沒有顯示。請大神幫忙 package com.example.send; import java.io.IOException; import java.io.In

PHP如何通過JSON-RPC與以太坊交互

mod 編程語言 hash bte ubun ffffff 創建 測試 pcc 自去年以來，我們正在開發區塊鏈（Blockchain）業務。最近使用過Ethereum並使用PHP，所以我想我們應該聊聊這個話題。 這裏有個前提： 1.理解區塊鏈 2.對編程語言有了解 本文

numpy之通過陣列與PIL.Image物件的互轉進行圖片處理

------------------------------------------------語法基礎------------------------------------------------ import numpy                        

python--boto3 之 與dynamoDB 的基本交互，表的備份與恢復

reg 可能 bsp scan exclusive 由於 ucc 時間 except 參考資料：http://boto3.readthedocs.io/en/latest/reference/services/dynamodb.html 最近因工作需要，研究了一下boto3

/etc/profile與/etc/bashrc、交互式與非交互式、login與non-login shell的差別

cached 運行 mit -m 相同 結果 cron 作文 ssh 線上的memcached又掛了。仍然沒有得到core文件。排查原因，同事發現啟動memcached的腳本存在可疑問題。 問題一：沒有設置memcached工作文件夾，有可能core dump時沒

IOS與js的簡單交互swift3版

utf8 bsp settitle height context scrip 什麽 super extension 在開發過程中，我們可能遇到ios代碼與js交互的情況,本人第一次使用遇到了很多坑，這裏紀錄一下，方便自己，也方便需要的人。 p.p1 { margin: 0.

PyQt5.9 Html與本地代碼交互實例

gis markdown gist channel bsp int str func hello 在PyQt5.9中, 應用QWebEngineView和QWebChannel技術, 可以進行HTML與本地代碼進行交互. 要點: 創建交互對象, 基於QObject, 定義

Linux文件系統---用戶與內核的交互接口

gbm 程序 系統環境 組成 linu 數據塊 ssd 其他 int 從磁盤到數據，從數據到文件，從文件到目錄，從目錄到文件系統，從文件系統到操作系統。構成了計算機中的IO讀寫機制。 整個磁盤可以分為1個MBR（Master Boot Record）和

springmvc與前端數據交互實例

面數據 sdn 打印 stp vax load bcd epo sta 一、從頁面接收參數 Spring MVC接收請求提交的參數值的幾種方法： 使用HttpServletRequest獲取。 @RequestMapping("/login.do")

ajax前臺與struts2中action交互詳見

gin def print ces 返回 collect jdk char int 第一種方法： 　　利用Servlet API,用response的.getWriter()方法獲得PrintWriter Action代碼: public Object ajax(){ 　

javaweb 與jsp頁面的交互流程 (初次接觸寫)

不返回 分享 new text == lac gree ons 交互 javaweb 與jsp頁面的交互流程 javaweb項目目錄 1. javaweb項目的一般目錄： 2. jsp 頁面一般情況下放在 top(前臺頁面) back(後臺頁面) 3. 後臺代碼 放在s

一個c#的與web服務器交互的HttpClient類

指示 all 斷點續傳 www. mod bytearray dex ron 發出 using System;using System.Collections.Generic;using System.IO;using System.Text;using System.Ne

Struts2與Ajax數據交互

json插件 通過 bsp pre 繼承 結果 而是 返回 input 寫在前面： 　　ajax請求在項目中常常使用,今天就平時掌握的總結一下，關於使用ajax請求到Struts2中的action時，前臺頁面與後臺action之間的數據傳遞交互問題。 　　這裏我主要記錄下自

瀏覽器與PHP程序的交互

PHP 交互 表單 get post 小程上一節介紹過怎麽在mac電腦上啟用PHP程序，並且演示了一個簡單的例子，這個例子運行時，涉及了瀏覽器、apache以及PHP程序的交互，這三者的關系大概是這樣的（讀者可以關註微信公眾號“廣州小程”以獲取歸類的知識與技能）： 一般來說，瀏覽器（或者類

vbs與其他語言進行交互編程（外存傳參）

one 自定義排序 RR 調用方法 i++ 命令 argc urn 例如 vbs沒有自定義排序函數。無需自己造輪子，可以用其他語言來完成這個任務（在傳遞數據比較簡單的情況下，例如只傳遞數組）。 首先用5分鐘寫一個C++排序的代碼。命名為“mysort.cpp”： #inc

nodejs與c語言深度交互

std inf 交互 passwd -m date char str bsp 2、node-ffi 1）nodejs從c語言讀取數據 factorial.c #include <stdint.h> #include <stdio.h>

×××平臺出租?一招搞定Windows與Linux間Python交互編程

多種語言與python混合編程最近碰到的項目大多是多種語言與python混合編程×××平臺出租? （www.1159880099.com） QQ1159880099 微信 Tel17061863533 源碼交易,源碼開發, ,技術交易,專註於為企業 、個人提供個性化定制解決方案，更加高效便捷的為廣大需求者