kpd_test_misc1.c

MMI层OBJ不能完全编译

							repeat_first = TRUE;
						}
				  }

				  /* Key Repeat press event => exit */
				  if(repeat_first == TRUE && repeat_second == TRUE)  
				  {
                      kpd_unsubscribe(&subscriber_id);
					  exit_test = TRUE;
				  }

                  break;
                  }

               case KPD_STATUS_MSG:
                  kpd_test_trace("Received status message in mailbox 0");
                  break;

               default :
                  break;

            }
            rvf_free_buf(msg_p);
         }
      }
   }

   /* calculate the long press time */
   calculated_time = long_time - first_time;
   calculated_time = RVF_TICKS_TO_MS(calculated_time);
   /* KpdLongPressCalculatedTime */
   strcpy (format->var_name, KPD_102_VAR_LGTIME);
   KpdResult &= gen_display_table_result_compare_UINT(&kpd_long_press_waited[0], &kpd_long_press_waited[1], &calculated_time, format);

   /* calculate the repeat time */
   calculated_time = repeat_time2 - repeat_time1;
   calculated_time = RVF_TICKS_TO_MS(calculated_time);
   /* KpdRepeatCalculatedTime */
   strcpy (format->var_name, KPD_102_VAR_RPTTIME);
   KpdResult &= gen_display_table_result_compare_UINT(&kpd_repeat_waited[0], &kpd_repeat_waited[1], &calculated_time, format);

   /* return test_verdict */
   gen_display_report (KpdResult);
   if (KpdResult)
{
  rtest_send_result(TEST_PASSED);
}
   else
   {
		rtest_send_result(TEST_FAILED);
   }
   
   /* Free structure allocation in RTEST */
   rvf_free_buf (format);

}


/************************************************************************/
/**
 * kpd_test_misc103
 *
 * Check the parameter boundary for kpd_register_for_timer_change() function
 *
 * @param  :	NA
 *				
 * @return :	void
 */
void kpd_test_misc103(void)
{
   T_KPD_SUBSCRIBER subscriber_id;
   T_KPD_VIRTUAL_KEY_TABLE notified_keys;
   T_RV_RETURN kpd_return_path;

   T_RV_RET kpd_id_waited[] = {RV_INVALID_PARAMETER, RV_INVALID_PARAMETER};
   T_RV_RET kpd_id_obtained[] = {RV_OK,RV_OK};
   BOOL KpdResult = TRUE;
   
    /* Structure allocation in RTEST */
   T_result_info *format;
   if (rvf_get_buf(rtest_get_mb_id(), sizeof(T_result_info), (T_RVF_BUFFER**) &format) == RVF_RED)
   {
	   rtest_send_result(TEST_FAILED);
	   RV_TEST_TRACE_ERROR("Memory allocation error - test not started");
	   return;
   }

   strcpy (format->test_ref, KPD_103_REF);
   strcpy (format->test_name, KPD_103_NAME);
   strcpy (format->test_comment, KPD_103_COMMENT);
   format->display_format = DIS_LONG;
   format->display_base = DIS_DEC;
   gen_display_header (format);

   /* Keypad registration */
   kpd_return_path.addr_id = rtest_get_addr_id() + 0;
   kpd_return_path.callback_func = 0;
   notified_keys.nb_notified_keys = KPD_NB_PHYSICAL_KEYS;
   kpd_subscribe (&subscriber_id,
                  KPD_DEFAULT_MODE,
                  &notified_keys,
                  kpd_return_path);

   /* API called with subscriber initialized with NULL parameter */
   kpd_id_obtained[0] = kpd_register_for_timerchanges(NULL, KPD_TIMER_LONG_PRESS);
   strcpy (format->var_name, KPD_103_VAR_ER1);
   KpdResult &= gen_display_table_result(&kpd_id_waited[0], &kpd_id_obtained[0], sizeof(kpd_id_waited[0]), format);

   /* API called with timer_type initialized with INSIGNIFICANT_VALUE parameter */
   kpd_id_obtained[1] = kpd_register_for_timerchanges(subscriber_id, 0xff);
   strcpy (format->var_name, KPD_103_VAR_ER2);
   KpdResult &= gen_display_table_result(&kpd_id_waited[1], &kpd_id_obtained[1], sizeof(kpd_id_waited[1]), format);
	   
   /* Keypad unregistration */
   kpd_unsubscribe (&subscriber_id);

   /* return test_verdict */
   gen_display_report (KpdResult);
   if (KpdResult)
   {
		rtest_send_result(TEST_PASSED);
   }
   else
   {
		rtest_send_result(TEST_FAILED);
   }
   
   /* Free structure allocation in RTEST */
   rvf_free_buf (format);
}


/************************************************************************/
/**
 * keypad_notification104
 *
 * Call back function for second subscriber in kpd_test_misc104 function
 *
 * @param  :	msg_p	: message received
 *				
 * @return :	void
 */
void keypad_notification104(void* msg_p)
{ 
   /* 2nd client */
   T_RV_HDR* msg_hdr_p = (T_RV_HDR*) msg_p;
   T_TEST_PARAM* kpd_msg;

    /* Structure allocation in RTEST */
   if (rvf_get_msg_buf(rtest_get_mb_id(), sizeof(T_TEST_PARAM), KPD_MSG_1, (T_RVF_MSG**) &kpd_msg) == RVF_RED)
   {
	   return;
   }

   /* initialize the message to send */
   kpd_msg->hdr.msg_id = KPD_MSG_1;
   if(msg_hdr_p->msg_id == KPD_KEYPAD_TIMEOUT_MSG)
   {
     /* timer change event */
	 T_KPD_KEYPAD_TIMEOUT_MSG* msg_timeout_event_p = (T_KPD_KEYPAD_TIMEOUT_MSG*) msg_p;
     kpd_test_trace("timeout event message for subscriber 2");
	 kpd_msg->MessageReceived = msg_timeout_event_p->timeout_type;
   }
   else
   {
	 kpd_msg->MessageReceived = 0;
   }
   
   /* send the message to RTEST */
   rvf_send_msg( rtest_get_addr_id(), (T_RV_HDR*) kpd_msg);
	
}


/**
 * kpd_test_misc104
 *
 * Check 2 subscribers are informed when a timeout occurs on the keypad
 *
 * @param  :	NA
 *				
 * @return :	void
 */
void kpd_test_misc104(void)
{
   UINT16         received_event;
   T_RV_HDR*      msg_p;
   BOOL           exit_test = FALSE;

   T_KPD_SUBSCRIBER subscriber_id0, subscriber_id1;
   T_KPD_VIRTUAL_KEY_TABLE notified_keys;
   T_RV_RETURN kpd_return_path;

   UINT32 kpd_id_waited[] = {KPD_TIMEOUT_NO_KEY, KPD_TIMEOUT_KEY_JAM, KPD_TIMEOUT_KEY_JAM, 0};
   UINT32 kpd_id_obtained[] = {0,0,0,0};
   UINT32 kpd2_id_waited[] = {KPD_TIMEOUT_NO_KEY, KPD_TIMEOUT_KEY_JAM, KPD_TIMEOUT_KEY_JAM,0};
   UINT32 kpd2_id_obtained[] = {0,0,0,0};

   T_RV_RET kpd_ret_waited[] = {RV_OK, RV_OK, RV_OK, RV_OK};
   T_RV_RET kpd_ret_obtained[] = {RV_NOT_SUPPORTED, RV_NOT_SUPPORTED, RV_NOT_SUPPORTED, RV_NOT_SUPPORTED};
   T_RV_RET kpd2_ret_waited[] = {RV_OK, RV_OK, RV_OK, RV_OK};
   T_RV_RET kpd2_ret_obtained[] = {RV_NOT_SUPPORTED, RV_NOT_SUPPORTED, RV_NOT_SUPPORTED, RV_NOT_SUPPORTED};

   BOOL KpdResult = TRUE;

   BOOL Key2Pressed = FALSE;
   BOOL Key89Pressed = FALSE;
   BOOL Key4Pressed = FALSE;
   BOOL KeydiesePressed = FALSE;

    /* Structure allocation in RTEST */
   T_result_info *format;
   if (rvf_get_buf(rtest_get_mb_id(), sizeof(T_result_info), (T_RVF_BUFFER**) &format) == RVF_RED)
   {
	   rtest_send_result(TEST_FAILED);
	   RV_TEST_TRACE_ERROR("Memory allocation error - test not started");
	   return;
   }

   strcpy (format->test_ref, KPD_104_REF);
   strcpy (format->test_name, KPD_104_NAME);
   strcpy (format->test_comment, KPD_104_COMMENT);
   format->display_format = DIS_LONG;
   format->display_base = DIS_DEC;
   gen_display_header (format);
   
   /** Keypad registration  **/
   /* Subscriber 1  */
   kpd_return_path.addr_id = rtest_get_addr_id() + 0;
   kpd_return_path.callback_func = NULL;
   notified_keys.nb_notified_keys = KPD_NB_PHYSICAL_KEYS;
   kpd_subscribe (&subscriber_id0,
                  KPD_DEFAULT_MODE,
                  &notified_keys,
                  kpd_return_path);
   /* Subscriber 2 */
   kpd_return_path.addr_id = 0;
   kpd_return_path.callback_func = keypad_notification104;
   notified_keys.nb_notified_keys = KPD_NB_PHYSICAL_KEYS;
   kpd_subscribe (&subscriber_id1,
                  KPD_DEFAULT_MODE,
                  &notified_keys,
                  kpd_return_path);
   
   /** Timeout registration : NO KEY **/
   /* Subscriber 1  */
   kpd_ret_obtained[0] = kpd_register_for_keypad_timeout(subscriber_id0, KPD_TIMEOUT_NO_KEY, 10000);
   strcpy (format->var_name, KPD_104_VAR_NO_KEY1);
   KpdResult &= gen_display_table_result(&kpd_ret_waited[0], &kpd_ret_obtained[0], sizeof(kpd_ret_waited[0]), format);
   /* Subscriber 2 */
   kpd2_ret_obtained[0] = kpd_register_for_keypad_timeout(subscriber_id1, KPD_TIMEOUT_NO_KEY, 10000);
   strcpy (format->var_name, KPD_104_VAR_NO_KEY2);
   KpdResult &= gen_display_table_result(&kpd2_ret_waited[0], &kpd2_ret_obtained[0], sizeof(kpd2_ret_waited[0]), format);

   /* Display test steps on the LCD screen  */
   LCD_Clear();
   LCD_WriteString (1, 0, "\n\n\nPress key * ", NORMAL);
   LCD_WriteString (1, 0, "\n\n\n\nand wait  15 seconds", NORMAL);
      
   /* loop to process messages */
   while (!exit_test)
   {
      /* Wait for the necessary events (infinite wait for a msg in the mailbox 0).*/
      received_event = rvf_wait(RVF_TASK_MBOX_0_EVT_MASK,0);

      if (received_event & RVF_TASK_MBOX_0_EVT_MASK)
      {
         /*debounce delay = 13 ms*/
		 rvf_delay(1);
         /* Read the message */
         msg_p = (T_RV_HDR *) rvf_read_mbox(0);

         if (msg_p->dest_addr_id == (rtest_get_addr_id() + 0))
         {
            switch (msg_p->msg_id)
            {
               case KPD_KEY_EVENT_MSG:
                  {
                  T_KPD_KEY_EVENT_MSG* msg_key_event_p = (T_KPD_KEY_EVENT_MSG*) msg_p;
                  display_message(msg_key_event_p, 2);
		  
				  /* Key 2 pressed */
				  if(msg_key_event_p->key_info.virtual_key_id == KPD_KEY_2)
				  {
					Key2Pressed = TRUE;
				  }

				  /* Key 8 or 9 pressed */
				  if( (msg_key_event_p->key_info.virtual_key_id == KPD_KEY_8) ||
					  (msg_key_event_p->key_info.virtual_key_id == KPD_KEY_9))
				  {
					Key89Pressed = TRUE;
				  }

				  /* Key 4 pressed */
				  if(msg_key_event_p->key_info.virtual_key_id == KPD_KEY_4)
				  {
					Key4Pressed = TRUE;
				  }

				  /* Key # pressed */
				  if(msg_key_event_p->key_info.virtual_key_id == KPD_KEY_DIESE)
				  {
					KeydiesePressed = TRUE;
				  }

				  /* Key ENTER pressed */
				  if( msg_key_event_p->key_info.virtual_key_id == KPD_KEY_ENTER)
				  {
                      kpd_unsubscribe(&subscriber_id0);
					  kpd_unsubscribe(&subscriber_id1);
					  exit_test = TRUE;
				  }
                  break;
                  }

               case KPD_KEYPAD_TIMEOUT_MSG:
				  {
				  T_KPD_KEYPAD_TIMEOUT_MSG* msg_changed_event_p = (T_KPD_KEYPAD_TIMEOUT_MSG*) msg_p;

				  /* key 8 or 9 have been pressed */
				  if((Key2Pressed == TRUE) && (Key89Pressed == TRUE) && (Key4Pressed == FALSE))
				  {
					  /* timeout type */
					  kpd_id_obtained[2] = (UINT32)msg_changed_event_p->timeout_type;
  					  strcpy (format->var_name, KPD_104_VAR_MORE_KEYS_MSG1);
  					  KpdResult &= gen_display_table_result(&kpd_id_waited[2], &kpd_id_obtained[2], sizeof(kpd_id_waited[2]), format);
					  
					  /* registration for keypad timeout none for the 2 subscribers */
					  kpd_ret_obtained[3] = kpd_register_for_keypad_timeout(subscriber_id0, KPD_TIMEOUT_NONE, 4000);
					  kpd2_ret_obtained[3] = kpd_register_for_keypad_timeout(subscriber_id1, KPD_TIMEOUT_NONE, 4000);

					  LCD_Clear();
				      LCD_WriteString (1, 0, "\n\n\nPress key # then ", NORMAL);
					  LCD_WriteString (1, 0, "\n\n\n\nkey 4 during 5 seconds  ",NORMAL);
					  LCD_WriteString (1, 0, "\n\n\n\n\nand then Key ENTER", NORMAL);
					  Key4Pressed = TRUE;
				  }				  

				  /* key 2 has been pressed */
				  if((Key2Pressed == TRUE) && (Key89Pressed == FALSE) && (Key4Pressed == FALSE))
				  {
					  /* timeout type */
					  kpd_id_obtained[1] = (UINT32)msg_changed_event_p->timeout_type;
  					  strcpy (format->var_name, KPD_104_VAR_ONE_KEY_MSG1);
  					  KpdResult &= gen_display_table_result(&kpd_id_waited[1], &kpd_id_obtained[1], sizeof(kpd_id_waited[1]), format);
					  
					  /* registration for keypad timeout more than one key still pressed
					     for the 2 subscribers */
					  kpd_ret_obtained[2] = kpd_register_for_keypad_timeout(subscriber_id0, KPD_TIMEOUT_KEY_JAM, 4000);
					  kpd2_ret_obtained[2] = kpd_register_for_keypad_timeout(subscriber_id1, KPD_TIMEOUT_KEY_JAM, 4000);

                      LCD_Clear();
					  LCD_WriteString (1, 0, "\n\n\nPress keys 8 and 9 ", NORMAL);
					  LCD_WriteString (1, 0, "\n\n\n\nduring 5 seconds ", NORMAL);
					  Key89Pressed = TRUE;