tests/mtpResponder.cpp

   1 /*
   2  * Copyright (c) 2017 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 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <iostream>
  20 #include <gmock/gmock.h>
  21 #include <gtest/gtest.h>
  22
  23 #include "mtpResponder.h"
  24
  25 MtpResponder::MtpResponder(void)
  26 {
  27
  28 }
  29
  30 MtpResponder::~MtpResponder(void)
  31 {
  32         _mtp_deinit();
  33 }
  34
  35
  36 int MtpResponder::mtp_init(add_rem_store_t sel)
  37 {
  38         _mtp_init(sel);
  39
  40         return ERROR_NONE;
  41 }
  42
  43 int MtpResponder::mtp_deinit(void)
  44 {
  45         add_rem_store_t sel = MTP_ADDREM_AUTO;
  46         _mtp_init(sel);
  47
  48         _mtp_deinit();
  49
  50         return ERROR_NONE;
  51 }
  52
  53 int MtpResponder::hutil_get_storage_entry(void)
  54 {
  55         int ret = 0;
  56         add_rem_store_t sel = MTP_ADDREM_AUTO;
  57         _mtp_init(sel);
  58
  59         ret = _hutil_get_storage_entry(0, NULL);
  60
  61         return ret;
  62 }
  63
  64 int MtpResponder::hutil_get_storage_ids(void)
  65 {
  66         int ret = 0;
  67         add_rem_store_t sel = MTP_ADDREM_AUTO;
  68         _mtp_init(sel);
  69
  70         ptp_array_t store_ids = {UINT32_TYPE, 0, 0, NULL};
  71
  72         ret = _hutil_get_storage_ids(&store_ids);
  73
  74         return ret;
  75 }
  76
  77 int MtpResponder::hutil_get_device_property(void)
  78 {
  79         int ret = 0;
  80         add_rem_store_t sel = MTP_ADDREM_AUTO;
  81         _mtp_init(sel);
  82
  83         ret = _hutil_get_device_property(0, NULL);
  84
  85         return ret;
  86 }
  87
  88 int MtpResponder::hutil_set_device_property(void)
  89 {
  90         int ret = 0;
  91         add_rem_store_t sel = MTP_ADDREM_AUTO;
  92         _mtp_init(sel);
  93
  94         ret = _hutil_set_device_property(0, NULL, 0);
  95
  96         return ret;
  97 }
  98
  99 int MtpResponder::hutil_reset_device_entry(void)
 100 {
 101         int ret = 0;
 102         add_rem_store_t sel = MTP_ADDREM_AUTO;
 103         _mtp_init(sel);
 104
 105         ret = _hutil_reset_device_entry(0);
 106
 107         return ret;
 108 }
 109
 110 int MtpResponder::hutil_add_object_entry(void)
 111 {
 112         int ret = 0;
 113         add_rem_store_t sel = MTP_ADDREM_AUTO;
 114         _mtp_init(sel);
 115
 116         ret = _hutil_add_object_entry(NULL, NULL, NULL);
 117
 118         return ret;
 119 }
 120
 121 int MtpResponder::hutil_remove_object_entry(void)
 122 {
 123         int ret = 0;
 124         add_rem_store_t sel = MTP_ADDREM_AUTO;
 125         _mtp_init(sel);
 126
 127         ret = _hutil_remove_object_entry(0, 0);
 128
 129         return ret;
 130 }
 131
 132 int MtpResponder::hutil_get_object_entry(void)
 133 {
 134         int ret = 0;
 135         add_rem_store_t sel = MTP_ADDREM_AUTO;
 136         _mtp_init(sel);
 137
 138         mtp_obj_t *ptr_mtp_obj = NULL;
 139         ret = _hutil_get_object_entry(0, &ptr_mtp_obj);
 140
 141         return ret;
 142 }
 143
 144 int MtpResponder::hutil_copy_object_entries(void)
 145 {
 146         int ret = 0;
 147         add_rem_store_t sel = MTP_ADDREM_AUTO;
 148         _mtp_init(sel);
 149
 150         mtp_uint32 new_hobj = 0;
 151         ret = _hutil_copy_object_entries(0, 0, 0, 0, &new_hobj, 0);
 152
 153         return ret;
 154 }
 155
 156 int MtpResponder::hutil_move_object_entry(void)
 157 {
 158         int ret = 0;
 159         add_rem_store_t sel = MTP_ADDREM_AUTO;
 160         _mtp_init(sel);
 161
 162         ret = _hutil_move_object_entry(0, 0, 0);
 163
 164         return ret;
 165 }
 166
 167 int MtpResponder::hutil_duplicate_object_entry(void)
 168 {
 169         int ret = 0;
 170         add_rem_store_t sel = MTP_ADDREM_AUTO;
 171         _mtp_init(sel);
 172
 173         mtp_uint32 new_handle = 0;
 174         ret = _hutil_duplicate_object_entry(0, 0, 0, &new_handle);
 175
 176         return ret;
 177 }
 178
 179 int MtpResponder::hutil_read_file_data_from_offset(void)
 180 {
 181         int ret = 0;
 182         add_rem_store_t sel = MTP_ADDREM_AUTO;
 183         _mtp_init(sel);
 184
 185         mtp_uint32 data_sz = 0;
 186         mtp_char data[] = "aaaaaaaaaa";
 187         ret = _hutil_read_file_data_from_offset(0, (off_t)0, (void*)data, &data_sz);
 188
 189         return ret;
 190 }
 191
 192 int MtpResponder::hutil_write_file_data(void)
 193 {
 194         int ret = 0;
 195         add_rem_store_t sel = MTP_ADDREM_AUTO;
 196         _mtp_init(sel);
 197
 198         mtp_char fpath[] = "/Phone/DCIM/abc.txt";
 199         ret = _hutil_write_file_data(0, NULL, fpath);
 200
 201         return ret;
 202 }
 203
 204 int MtpResponder::hutil_get_object_entry_size(void)
 205 {
 206         int ret = 0;
 207         add_rem_store_t sel = MTP_ADDREM_AUTO;
 208         _mtp_init(sel);
 209
 210         mtp_uint64 obj_sz = 0;
 211         ret = _hutil_get_object_entry_size(0, &obj_sz);
 212
 213         return ret;
 214 }
 215
 216 #ifdef MTP_SUPPORT_SET_PROTECTION
 217 int MtpResponder::hutil_set_protection(void)
 218 {
 219         int ret = 0;
 220         add_rem_store_t sel = MTP_ADDREM_AUTO;
 221         _mtp_init(sel);
 222
 223         ret = _hutil_set_protection(0, 0);
 224
 225         return ret;
 226 }
 227 #endif /* MTP_SUPPORT_SET_PROTECTION */
 228
 229 int MtpResponder::hutil_get_num_objects(void)
 230 {
 231         int ret = 0;
 232         add_rem_store_t sel = MTP_ADDREM_AUTO;
 233         _mtp_init(sel);
 234
 235         mtp_uint32 num_obj = 0;
 236         ret = _hutil_get_num_objects(0, 0, 0, &num_obj);
 237
 238         return ret;
 239 }
 240
 241 int MtpResponder::hutil_get_object_handles(void)
 242 {
 243         int ret = 0;
 244         add_rem_store_t sel = MTP_ADDREM_AUTO;
 245         _mtp_init(sel);
 246
 247         ptp_array_t handle_arr = {UINT32_TYPE, 0, 0, NULL};
 248         ret = _hutil_get_object_handles(0, 0, 0, &handle_arr);
 249
 250         return ret;
 251 }
 252
 253 int MtpResponder::hutil_construct_object_entry(void)
 254 {
 255         int ret = 0;
 256         add_rem_store_t sel = MTP_ADDREM_AUTO;
 257         _mtp_init(sel);
 258
 259         obj_data_t obj_data = {0, 0, NULL};
 260         mtp_obj_t *mtp_obj = NULL;
 261         mtp_char data[] = "aaaaaaaaa";
 262         ret = _hutil_construct_object_entry(0, 0, &obj_data, &mtp_obj, (void*)data, 0);
 263
 264         return ret;
 265 }
 266
 267 //========================================
 268
 269 int MtpResponder::hutil_construct_object_entry_prop_list(void)
 270 {
 271         int ret = 0;
 272         add_rem_store_t sel = MTP_ADDREM_AUTO;
 273         _mtp_init(sel);
 274
 275         obj_data_t obj_data = {0, 0, NULL};
 276         mtp_obj_t *mtp_obj = NULL;
 277         mtp_char data[] = "aaaaaaaaa";
 278         mtp_uint32 err_idx = 0;
 279         ret = _hutil_construct_object_entry_prop_list(0, 0, 0, 0, &obj_data, &mtp_obj, (void*)data, 0, &err_idx);
 280
 281         return ret;
 282 }
 283
 284 int MtpResponder::hutil_get_object_prop_value(void)
 285 {
 286         int ret = 0;
 287         add_rem_store_t sel = MTP_ADDREM_AUTO;
 288         _mtp_init(sel);
 289
 290         mtp_obj_t *mtp_obj = NULL;
 291         ret = _hutil_get_object_prop_value(0, 0, NULL, &mtp_obj);
 292
 293         return ret;
 294 }
 295
 296 int MtpResponder::hutil_update_object_property(void)
 297 {
 298         int ret = 0;
 299         add_rem_store_t sel = MTP_ADDREM_AUTO;
 300         _mtp_init(sel);
 301
 302         mtp_uint16 data_type = 0;
 303         mtp_char buf[] = "aaaaaa";
 304         mtp_uint32 prop_sz = 0;
 305         ret = _hutil_update_object_property(0, 0, &data_type, (void*)buf, 0, &prop_sz);
 306
 307         return ret;
 308 }
 309
 310 int MtpResponder::hutil_get_prop_desc(void)
 311 {
 312         int ret = 0;
 313         add_rem_store_t sel = MTP_ADDREM_AUTO;
 314         _mtp_init(sel);
 315
 316         mtp_char data[] = "aaaaaa";
 317         ret = _hutil_get_prop_desc(0, 0, &data);
 318
 319         return ret;
 320 }
 321
 322 int MtpResponder::hutil_get_object_prop_supported(void)
 323 {
 324         int ret = 0;
 325         add_rem_store_t sel = MTP_ADDREM_AUTO;
 326         _mtp_init(sel);
 327
 328         ptp_array_t prop_arr = {UINT32_TYPE, 0, 0, NULL};
 329
 330         ret = _hutil_get_object_prop_supported(0, &prop_arr);
 331
 332         return ret;
 333 }
 334
 335 int MtpResponder::hutil_get_object_prop_list(void)
 336 {
 337         int ret = 0;
 338         add_rem_store_t sel = MTP_ADDREM_AUTO;
 339         _mtp_init(sel);
 340
 341         ptp_array_t obj_arr = {UINT32_TYPE, 0, 0, NULL};
 342
 343         #ifdef MTP_USE_RUNTIME_GETOBJECTPROPVALUE
 344         ret = _hutil_get_object_prop_list(0, 0, 0, 0, 0, NULL, &obj_arr);
 345         #else /* MTP_USE_RUNTIME_GETOBJECTPROPVALUE */
 346         ret = _hutil_get_object_prop_list(0, 0, 0, 0, 0, NULL);
 347         #endif /* MTP_USE_RUNTIME_GETOBJECTPROPVALUE */
 348
 349         return ret;
 350 }
 351
 352 int MtpResponder::hutil_add_object_references_enhanced(void)
 353 {
 354         int ret = 0;
 355         add_rem_store_t sel = MTP_ADDREM_AUTO;
 356         _mtp_init(sel);
 357
 358         mtp_uchar buffer[] = "aaaaaaaa";
 359         ret = _hutil_add_object_references_enhanced(0, buffer, 0);
 360
 361         return ret;
 362 }
 363
 364 int MtpResponder::hutil_remove_object_reference(void)
 365 {
 366         int ret = 0;
 367         add_rem_store_t sel = MTP_ADDREM_AUTO;
 368         _mtp_init(sel);
 369
 370         ret = _hutil_remove_object_reference(0, 0);
 371
 372         return ret;
 373 }
 374
 375 int MtpResponder::hutil_get_object_references(void)
 376 {
 377         int ret = 0;
 378         add_rem_store_t sel = MTP_ADDREM_AUTO;
 379         _mtp_init(sel);
 380
 381         ptp_array_t parray = {UINT32_TYPE, 0, 0, NULL};
 382         mtp_uint32 num_ele = 0;
 383         ret = _hutil_get_object_references(0, &parray, &num_ele);
 384
 385         return ret;
 386 }
 387
 388 int MtpResponder::hutil_get_number_of_objects(void)
 389 {
 390         int ret = 0;
 391         add_rem_store_t sel = MTP_ADDREM_AUTO;
 392         _mtp_init(sel);
 393
 394         mtp_uint32 num_obj = 0;
 395         ret = _hutil_get_number_of_objects(0, &num_obj);
 396
 397         return ret;
 398 }
 399
 400 int MtpResponder::hutil_get_interdep_prop_config_list_size(void)
 401 {
 402         int ret = 0;
 403         add_rem_store_t sel = MTP_ADDREM_AUTO;
 404         _mtp_init(sel);
 405
 406         mtp_uint32 list_sz = 0;
 407         ret = _hutil_get_interdep_prop_config_list_size(&list_sz, 0);
 408
 409         return ret;
 410 }
 411
 412 int MtpResponder::hutil_get_interdep_prop_config_list_data(void)
 413 {
 414         int ret = 0;
 415         add_rem_store_t sel = MTP_ADDREM_AUTO;
 416         _mtp_init(sel);
 417
 418         mtp_char data[] = "aaaaaaaa";
 419         ret = _hutil_get_interdep_prop_config_list_data(data, 0, 0);
 420
 421         return ret;
 422 }
 423
 424 int MtpResponder::hutil_get_playback_skip(void)
 425 {
 426         int ret = 0;
 427         add_rem_store_t sel = MTP_ADDREM_AUTO;
 428         _mtp_init(sel);
 429
 430         ret = _hutil_get_playback_skip(0);
 431
 432         return ret;
 433 }
 434
 435 int MtpResponder::hutil_format_storage(void)
 436 {
 437         int ret = 0;
 438         add_rem_store_t sel = MTP_ADDREM_AUTO;
 439         _mtp_init(sel);
 440
 441         ret = _hutil_format_storage(0, 0);
 442
 443         return ret;
 444 }
 445
 446 int MtpResponder::hutil_get_storage_info_size(void)
 447 {
 448         add_rem_store_t sel = MTP_ADDREM_AUTO;
 449         _mtp_init(sel);
 450
 451         int ret_size = -1;
 452         store_info_t store_info;
 453         ret_size = _hutil_get_storage_info_size(&store_info);
 454
 455         if (ret_size >= 0)
 456                 return ERROR_NONE;
 457         return ERROR_OPERATION_FAILED;
 458 }
 459
 460 //================== _MTP_CMD_HANDLER_H_ ======================
 461
 462 int MtpResponder::cmd_hdlr_send_response(void)
 463 {
 464         int ret = 0;
 465         add_rem_store_t sel = MTP_ADDREM_AUTO;
 466         _mtp_init(sel);
 467
 468         mtp_uint32 params = 0;
 469         ret = _cmd_hdlr_send_response(NULL, 0, 0, &params);
 470
 471         return ret;
 472 }
 473
 474 int MtpResponder::cmd_hdlr_send_response_code(void)
 475 {
 476         int ret = 0;
 477         add_rem_store_t sel = MTP_ADDREM_AUTO;
 478         _mtp_init(sel);
 479
 480         ret = _cmd_hdlr_send_response_code(NULL, 0);
 481
 482         return ret;
 483 }
 484
 485 //================== _MTP_EVENT_HANDLER_H_ ======================
 486
 487 int MtpResponder::hdlr_get_param_cmd_container(void)
 488 {
 489         int ret = 0;
 490
 491         cmd_container_t cntr;
 492         mtp_uint32 index = 0;
 493         _hdlr_init_cmd_container(&cntr);
 494
 495         ret = _hdlr_get_param_cmd_container(&cntr, index);
 496
 497         return ret;
 498 }
 499
 500 int MtpResponder::hdlr_add_param_resp_container(void)
 501 {
 502         int ret = 0;
 503
 504         cmd_container_t cntr;
 505         cmd_container_t dst;
 506         mtp_uint32 param = 0;
 507         _hdlr_init_cmd_container(&cntr);
 508         _hdlr_copy_cmd_container(&cntr, &dst);
 509
 510         ret = _hdlr_add_param_resp_container(&dst, 0, &param);
 511
 512         return (!ret);
 513 }
 514
 515 int MtpResponder::hdlr_validate_cmd_container(void)
 516 {
 517         int ret = 0;
 518
 519         cmd_container_t cntr;
 520         _hdlr_init_cmd_container(&cntr);
 521
 522         ret = _hdlr_validate_cmd_container((mtp_uchar*)&cntr, 0);
 523
 524         return (!ret);
 525 }
 526
 527 int MtpResponder::hdlr_alloc_buf_data_container(void)
 528 {
 529         data_container_t dst;
 530         _hdlr_init_data_container(&dst, 0, 0);
 531
 532         mtp_uchar *ptr = NULL;
 533         ptr = _hdlr_alloc_buf_data_container(&dst, 0, 0);
 534
 535         if (ptr == NULL)
 536                 return ERROR_OPERATION_FAILED;
 537         return ERROR_NONE;
 538 }
 539
 540 int MtpResponder::hdlr_send_data_container(void)
 541 {
 542         int ret = 0;
 543
 544         data_container_t dst;
 545         _hdlr_init_data_container(&dst, 0, 0);
 546         _hdlr_alloc_buf_data_container(&dst, 0, 0);
 547
 548         ret = _hdlr_send_data_container(&dst);
 549
 550         return ret;
 551 }
 552
 553 int MtpResponder::hdlr_send_bulk_data(void)
 554 {
 555         int ret = 0;
 556
 557         data_container_t dst;
 558         _hdlr_init_data_container(&dst, 0, 0);
 559
 560         ret = _hdlr_send_bulk_data((mtp_uchar*)&dst, sizeof(data_container_t));
 561
 562         return ret;
 563 }
 564
 565 int MtpResponder::hdlr_rcv_data_container(void)
 566 {
 567         int ret = 0;
 568
 569         data_container_t dst;
 570         _hdlr_init_data_container(&dst, 0, 0);
 571
 572         ret = _hdlr_rcv_data_container(&dst, 0);
 573
 574         return ret;
 575 }
 576
 577 int MtpResponder::hdlr_get_payload_size(void)
 578 {
 579         int payload_size = -1;
 580
 581         data_container_t dst;
 582         _hdlr_init_data_container(&dst, 0, 0);
 583
 584         payload_size = _hdlr_get_payload_size(&dst);
 585
 586         if (payload_size >= 0)
 587                 return ERROR_NONE;
 588         return ERROR_OPERATION_FAILED;
 589 }
 590
 591 int MtpResponder::hdlr_get_payload_data(void)
 592 {
 593         mtp_uchar *ptr = NULL;
 594
 595         data_container_t dst;
 596         _hdlr_init_data_container(&dst, 0, 0);
 597         _hdlr_alloc_buf_data_container(&dst, 0, 0);
 598
 599         ptr = _hdlr_get_payload_data(&dst);
 600
 601         if (ptr != NULL)
 602                 return ERROR_NONE;
 603         return ERROR_OPERATION_FAILED;
 604 }
 605
 606 int MtpResponder::hdlr_resp_container_init(void)
 607 {
 608         cmd_container_t dst;
 609         _hdlr_resp_container_init(&dst, 0, 0);
 610
 611         return ERROR_NONE;
 612 }
 613
 614 int MtpResponder::hdlr_init_event_container(void)
 615 {
 616         cmd_container_t dst;
 617         _hdlr_init_event_container(&dst, 0, 0, 0, 0);
 618
 619         return ERROR_NONE;
 620 }
 621
 622 int MtpResponder::hdlr_init_event_container_with_param(void)
 623 {
 624         cmd_container_t dst;
 625         _hdlr_init_event_container_with_param(&dst, 0, 0, 0, 0);
 626
 627         return ERROR_NONE;
 628 }
 629
 630 int MtpResponder::hdlr_conv_cmd_container_byte_order(void)
 631 {
 632         cmd_container_t dst;
 633         _hdlr_conv_cmd_container_byte_order(&dst);
 634
 635         return ERROR_NONE;
 636 }
 637
 638 int MtpResponder::hdlr_conv_data_container_byte_order(void)
 639 {
 640         data_container_t dst;
 641         _hdlr_conv_data_container_byte_order(&dst);
 642
 643         return ERROR_NONE;
 644 }
 645
 646
 647
 648
 649
 650