[Exif] - Removing TODO from the module

Change-Id: I57daa110a298154576ed98c0b800f16c97f0aaa3
Signed-off-by: Andrzej Popowski <a.popowski@samsung.com>

diff --git a/src/exif/exif_api.js b/src/exif/exif_api.js
index 40face0..9970ce6 100755 (executable)
--- a/src/exif/exif_api.js
+++ b/src/exif/exif_api.js
@@ -359,21 +359,6 @@ tizen.ExifInformation = function() {
       gpsTime_ = null,
       userComment_ = null;
 
-  function _validateISOSpeedRatings(v) {
-    var valid = false;
-    if (type_.isArray(v)) {
-      for (var i = 0; i < v.length; i++) {
-        var data = v[i]; // todo: uncomment when array conversion is implemented.
-        //if (!type_.isNumber(data)) {
-        //  return false;
-        //}
-      }
-      valid = true;
-    }
-    return valid;
-  }
-
-
   var exifInitDict = args.ExifInitDict;
   if (exifInitDict) {
     if (exifInitDict.uri === null) {
@@ -465,9 +450,15 @@ tizen.ExifInformation = function() {
         return isoSpeedRatings_;
       },
       set: function(v) {
-        // todo: convert string array into unsigned short array
         if (!type_.isUndefined(v)) {
-          if (v === null || _validateISOSpeedRatings(v)) isoSpeedRatings_ = v;
+          if (v === null) {
+            isoSpeedRatings_ = null;
+          } else if (type_.isArray(v)) {
+            for (var i = 0; i < v.length; i++) {
+              v[i] = converter_.toUnsignedShort(v[i], false);
+            }
+            isoSpeedRatings_ = v;
+          }
         }
       },
       enumerable: true

diff --git a/src/exif/exif_information.cc b/src/exif/exif_information.cc
index dce7ff3..927c533 100755 (executable)
--- a/src/exif/exif_information.cc
+++ b/src/exif/exif_information.cc
@@ -708,52 +708,79 @@ void ExifInformation::removeNulledAttributesFromExifData(ExifData* exif_data) {
   }
 }
 
-void ExifInformation::updateAttributesInExifData(ExifData* exif_data) {
+PlatformResult ExifInformation::updateAttributesInExifData(ExifData* exif_data) {
   LoggerD("Entered");
+
+  common::PlatformResult ret(common::ErrorCode::NO_ERROR);
+
   AssertMsg(exif_data, "exif_data is NULL");
 
   if (isSet(EXIF_INFORMATION_ATTRIBUTE_WIDTH)) {
     LoggerD("Saving width: %d", getWidth());
-    ExifTagSaver::saveToExif(getWidth(),
-        EXIF_TAG_IMAGE_WIDTH, exif_data);
+    ret = ExifTagSaver::saveToExif(getWidth(), 
+                                   EXIF_TAG_IMAGE_WIDTH, exif_data);
+    if (!ret) {
+      return ret;
+    }
   }
   if (isSet(EXIF_INFORMATION_ATTRIBUTE_HEIGHT)) {
     LoggerD("Saving height: %d", getHeight());
-    ExifTagSaver::saveToExif(getHeight(),
-        EXIF_TAG_IMAGE_LENGTH, exif_data);
+    ret = ExifTagSaver::saveToExif(getHeight(),
+                                   EXIF_TAG_IMAGE_LENGTH, exif_data);
+    if (!ret) {
+      return ret;
+    }
   }
   if (isSet(EXIF_INFORMATION_ATTRIBUTE_DEVICE_MAKER)) {
     LoggerD("Saving device maker: %s", getDeviceMaker().c_str());
-    ExifTagSaver::saveToExif(getDeviceMaker(),
-        EXIF_TAG_MAKE, exif_data);
+    ret = ExifTagSaver::saveToExif(getDeviceMaker(),
+                                   EXIF_TAG_MAKE, exif_data);
+    if (!ret) {
+      return ret;
+    }
   }
   if (isSet(EXIF_INFORMATION_ATTRIBUTE_ORIENTATION)) {
     LoggerD("Saving orientation: %d", static_cast<int>(getOrientation()));
-    ExifTagSaver::saveToExif(static_cast<long int>(getOrientation()),
-        EXIF_TAG_ORIENTATION, exif_data);
+    ret = ExifTagSaver::saveToExif(static_cast<long int>(getOrientation()),
+                                   EXIF_TAG_ORIENTATION, exif_data);
+    if (!ret) {
+      return ret;
+    }
   }
   if (isSet(EXIF_INFORMATION_ATTRIBUTE_EXPOSURE_PROGRAM)) {
     LoggerD("Saving exposure program: %d",
         static_cast<int>(getExposureProgram()));
-    ExifTagSaver::saveToExif(getExposureProgram(),
-        EXIF_TAG_EXPOSURE_PROGRAM, exif_data);
+    ret = ExifTagSaver::saveToExif(getExposureProgram(),
+                                   EXIF_TAG_EXPOSURE_PROGRAM, exif_data);
+    if (!ret) {
+      return ret;
+    }
   }
   if (isSet(EXIF_INFORMATION_ATTRIBUTE_ISO_SPEED_RATINGS)) {
     std::vector<long long int> iso_ratings = getIsoSpeedRatings();
     LoggerD("Saving iso speed ratings count:%d", iso_ratings.size());
-    ExifTagSaver::saveToExif(iso_ratings, EXIF_FORMAT_SHORT,
-       EXIF_TAG_ISO_SPEED_RATINGS, exif_data);
+    ret = ExifTagSaver::saveToExif(iso_ratings, EXIF_FORMAT_SHORT,
+                                   EXIF_TAG_ISO_SPEED_RATINGS, exif_data);
+    if (!ret) {
+      return ret;
+    }
   }
   if (isSet(EXIF_INFORMATION_ATTRIBUTE_WHITE_BALANCE)) {
     LoggerD("Saving white balance: %d",
         static_cast<int>(getWhiteBalanceMode()));
-    ExifTagSaver::saveToExif(getWhiteBalanceMode(),
-        EXIF_TAG_WHITE_BALANCE, exif_data);
+    ret = ExifTagSaver::saveToExif(getWhiteBalanceMode(),
+                                   EXIF_TAG_WHITE_BALANCE, exif_data);
+    if (!ret) {
+      return ret;
+    }
   }
   if (isSet(EXIF_INFORMATION_ATTRIBUTE_DEVICE_MODEL)) {
     LoggerD("Saving device model: %s", getDeviceModel().c_str());
-    ExifTagSaver::saveToExif(getDeviceModel(),
-        EXIF_TAG_MODEL, exif_data);
+    ret = ExifTagSaver::saveToExif(getDeviceModel(),
+                                   EXIF_TAG_MODEL, exif_data);
+    if (!ret) {
+      return ret;
+    }
   }
   if (isSet(EXIF_INFORMATION_ATTRIBUTE_ORIGINAL_TIME)) {
     const time_t o_time = getOriginalTime();
@@ -762,8 +789,11 @@ void ExifInformation::updateAttributesInExifData(ExifData* exif_data) {
     LoggerD("Saving original time time_t:%d, format:%s",
         static_cast<int>(o_time), o_time_str.c_str());
 
-    ExifTagSaver::saveToExif(o_time_str,
-        EXIF_TAG_DATE_TIME_ORIGINAL, exif_data);
+    ret = ExifTagSaver::saveToExif(o_time_str,
+                                   EXIF_TAG_DATE_TIME_ORIGINAL, exif_data);
+    if (!ret) {
+      return ret;
+    }
   }
   if (isSet(EXIF_INFORMATION_ATTRIBUTE_EXPOSURE_TIME)) {
     Rational exposure_time = getExposureTime();
@@ -772,38 +802,56 @@ void ExifInformation::updateAttributesInExifData(ExifData* exif_data) {
           exposure_time.toString().c_str(),
           exposure_time.toExposureTimeString().c_str());
 
-      ExifTagSaver::saveToExif(exposure_time,
-          EXIF_TAG_EXPOSURE_TIME, exif_data);
+      ret = ExifTagSaver::saveToExif(exposure_time,
+                                     EXIF_TAG_EXPOSURE_TIME, exif_data);
+      if (!ret) {
+        return ret;
+      }
     }
   }
   if (isSet(EXIF_INFORMATION_ATTRIBUTE_FNUMBER)) {
     auto f_number = getFNumber();
     LoggerD("Saving f-number: %f (%s)", f_number.toDouble(),
         f_number.toString().c_str());
-    ExifTagSaver::saveToExif(f_number,
-        EXIF_TAG_FNUMBER, exif_data);
+    ret = ExifTagSaver::saveToExif(f_number,
+                                   EXIF_TAG_FNUMBER, exif_data);
+    if (!ret) {
+      return ret;
+    }
   }
   if (isSet(EXIF_INFORMATION_ATTRIBUTE_FLASH)) {
     LoggerD("Saving flash: %s", getFlash() ? "ON" : "OFF");
-    ExifTagSaver::saveToExif(getFlash(),
-        EXIF_TAG_FLASH, exif_data);
+    ret = ExifTagSaver::saveToExif(getFlash(),
+                                   EXIF_TAG_FLASH, exif_data);
+    if (!ret) {
+      return ret;
+    }
   }
   if (isSet(EXIF_INFORMATION_ATTRIBUTE_FOCAL_LENGTH)) {
     auto f_length = getFocalLength();
     LoggerD("Saving focal length:%f (%s)", f_length.toDouble(),
         f_length.toString().c_str());
-    ExifTagSaver::saveToExif(f_length,
-        EXIF_TAG_FOCAL_LENGTH, exif_data);
+    ret = ExifTagSaver::saveToExif(f_length,
+                                   EXIF_TAG_FOCAL_LENGTH, exif_data);
+    if (!ret) {
+      return ret;
+    }
   }
   if (isSet(EXIF_INFORMATION_ATTRIBUTE_GPS_LOCATION)) {
     LoggerD("Saving gps location");
-    ExifTagSaver::saveGpsLocationToExif(m_gps_location, exif_data);
+    ret = ExifTagSaver::saveGpsLocationToExif(m_gps_location, exif_data);
+    if (!ret) {
+      return ret;
+    }
   }
   if (isSet(EXIF_INFORMATION_ATTRIBUTE_GPS_ALTITUDE)) {
     LoggerD("Saving gps altitude:%f (%s)", m_gps_altitude.toDouble(),
          m_gps_altitude.toString().c_str());
-    ExifTagSaver::saveToExif(m_gps_altitude,
-        static_cast<ExifTag>(EXIF_TAG_GPS_ALTITUDE), exif_data);
+    ret = ExifTagSaver::saveToExif(m_gps_altitude,
+                                   static_cast<ExifTag>(EXIF_TAG_GPS_ALTITUDE), exif_data);
+    if (!ret) {
+      return ret;
+    }
   }
   if (isSet(EXIF_INFORMATION_ATTRIBUTE_GPS_ALTITUDE_REF)) {
     // Exif spec:
@@ -815,8 +863,11 @@ void ExifInformation::updateAttributesInExifData(ExifData* exif_data) {
     std::vector<long long int> value = {
       static_cast<long long int>(m_gps_altitude_ref)
     };
-    ExifTagSaver::saveToExif(value, EXIF_FORMAT_BYTE,
-        static_cast<ExifTag>(EXIF_TAG_GPS_ALTITUDE_REF), exif_data);
+    ret = ExifTagSaver::saveToExif(value, EXIF_FORMAT_BYTE,
+                                   static_cast<ExifTag>(EXIF_TAG_GPS_ALTITUDE_REF), exif_data);
+    if (!ret) {
+      return ret;
+    }
   }
   if (isSet(EXIF_INFORMATION_ATTRIBUTE_GPS_PROCESSING_METHOD)) {
     LoggerD("Saving gps processing method: [%s] type:%s",
@@ -826,9 +877,12 @@ void ExifInformation::updateAttributesInExifData(ExifData* exif_data) {
         getGpsProcessingMethod();
     LoggerD("joined: [%s]", joined.c_str());
 
-    ExifTagSaver::saveToExif(joined,
-        static_cast<ExifTag>(EXIF_TAG_GPS_PROCESSING_METHOD), exif_data,
-        EXIF_FORMAT_UNDEFINED, false);
+    ret = ExifTagSaver::saveToExif(joined,
+                                   static_cast<ExifTag>(EXIF_TAG_GPS_PROCESSING_METHOD), exif_data,
+                                   EXIF_FORMAT_UNDEFINED, false);
+    if (!ret) {
+      return ret;
+    }
   }
   if (isSet(EXIF_INFORMATION_ATTRIBUTE_GPS_TIME)) {
     const time_t gps_time = getGpsTime();
@@ -837,14 +891,20 @@ void ExifInformation::updateAttributesInExifData(ExifData* exif_data) {
         ExifUtil::timeTToExifGpsDateStamp(gps_time);
     LoggerD("Saving gps time stamp time_t: %d", static_cast<int>(gps_time));
 
-    ExifTagSaver::saveToExif(gps_time_vec,
-        static_cast<ExifTag>(EXIF_TAG_GPS_TIME_STAMP), exif_data);
+    ret = ExifTagSaver::saveToExif(gps_time_vec,
+                                   static_cast<ExifTag>(EXIF_TAG_GPS_TIME_STAMP), exif_data);
+    if (!ret) {
+      return ret;
+    }
 
     LoggerD("Saving gps date stamp: %s", gps_date_str.c_str());
 
-    ExifTagSaver::saveToExif(gps_date_str,
-        static_cast<ExifTag>(EXIF_TAG_GPS_DATE_STAMP), exif_data,
-        EXIF_FORMAT_ASCII, false);
+    ret = ExifTagSaver::saveToExif(gps_date_str,
+                                   static_cast<ExifTag>(EXIF_TAG_GPS_DATE_STAMP), exif_data,
+                                   EXIF_FORMAT_ASCII, false);
+    if (!ret) {
+      return ret;
+    }
   }
   if (isSet(EXIF_INFORMATION_ATTRIBUTE_USER_COMMENT)) {
     LoggerD("Saving user comment: %s (type:%s)", getUserComment().c_str(),
@@ -853,9 +913,14 @@ void ExifInformation::updateAttributesInExifData(ExifData* exif_data) {
     const std::string& joined = getUserCommentType() + getUserComment();
     LoggerD("joined: [%s]", joined.c_str());
 
-    ExifTagSaver::saveToExif(joined,
-        EXIF_TAG_USER_COMMENT, exif_data, EXIF_FORMAT_UNDEFINED, false);
+    ret = ExifTagSaver::saveToExif(joined,
+                                   EXIF_TAG_USER_COMMENT, exif_data, EXIF_FORMAT_UNDEFINED, false);
+    if (!ret) {
+      return ret;
+    }
   }
+
+  return ret;
 }
 
 PlatformResult ExifInformation::saveToFile(const std::string& file_path) {
@@ -897,7 +962,11 @@ PlatformResult ExifInformation::saveToFile(const std::string& file_path) {
     // Remove attributes that have been nulled
     removeNulledAttributesFromExifData(exif_data);
   }
-  updateAttributesInExifData(exif_data);
+  result = updateAttributesInExifData(exif_data);
+  if (!result) {
+    exif_data_unref(exif_data);
+    return result;
+  }
 
   LoggerD("Using JpegFile to save new Exif in: [%s]", file_path.c_str());
   if (exif_data_is_new) {

diff --git a/src/exif/exif_information.h b/src/exif/exif_information.h
index 237c37a..809ac44 100755 (executable)
--- a/src/exif/exif_information.h
+++ b/src/exif/exif_information.h
@@ -211,7 +211,7 @@ class ExifInformation {
 
  private:
   void removeNulledAttributesFromExifData(ExifData* exif_data);
-  void updateAttributesInExifData(ExifData* exif_data);
+  common::PlatformResult updateAttributesInExifData(ExifData* exif_data);
 
   std::string m_uri;
   unsigned long m_width;

diff --git a/src/exif/exif_instance.cc b/src/exif/exif_instance.cc
index b4d6446..4687020 100755 (executable)
--- a/src/exif/exif_instance.cc
+++ b/src/exif/exif_instance.cc
@@ -61,7 +61,6 @@ void ExifInstance::ExifManagerGetExifInfo(const picojson::value& args, picojson:
       JsonValue result = JsonValue(JsonObject());
       PlatformResult status(ErrorCode::NO_ERROR);
 
-      // TODO(r.galka) it can be done on JS side
       const std::string &file_path = ExifUtil::convertUriToPath(uri);
       LoggerD("file_path = %s", file_path.c_str());
 
@@ -96,7 +95,6 @@ void ExifInstance::ExifManagerSaveExifInfo(const picojson::value& args,
 
       ExifInformationPtr exifInfo(new ExifInformation(args));
       const std::string& uri = exifInfo->getUri();
-      // TODO(r.galka) it can be done on JS side
       const std::string& path = ExifUtil::convertUriToPath(uri);
       status = exifInfo->saveToFile(path);
 
@@ -126,7 +124,6 @@ void ExifInstance::ExifManagerGetThumbnail(const picojson::value& args,
   auto get = [=](const std::shared_ptr<JsonValue> &response) -> void {
       PlatformResult status(ErrorCode::NO_ERROR);
 
-      // TODO(r.galka) it can be done on JS side
       const std::string &file_path = ExifUtil::convertUriToPath(uri);
       JsonValue result = JsonValue(JsonObject());
       JsonObject &result_obj = result.get<JsonObject>();

diff --git a/src/exif/exif_tag_saver.cc b/src/exif/exif_tag_saver.cc
index cbb6e02..a301a67 100755 (executable)
--- a/src/exif/exif_tag_saver.cc
+++ b/src/exif/exif_tag_saver.cc
@@ -39,14 +39,14 @@ void ExifTagSaver::removeExifEntryWithTag(const ExifTag tag,
   exif_content_remove_entry(exif_entry->parent, exif_entry);
 }
 
-void ExifTagSaver::saveToExif(long int value, ExifTag tag,
-                              ExifData* exif_data) {
+common::PlatformResult ExifTagSaver::saveToExif(long int value, ExifTag tag,
+                                                ExifData* exif_data) {
   LoggerD("Entered");
+
   ExifEntry* entry = prepareEntry(exif_data, tag);
   if (!entry) {
-    // TODO return PlatformResult and handle error
     LoggerE("Exif entry is null");
-    return;
+    return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, "Exif entry is null");
   }
 
   ExifByteOrder order = exif_data_get_byte_order(exif_data);
@@ -73,19 +73,20 @@ void ExifTagSaver::saveToExif(long int value, ExifTag tag,
     }
     default: {
       LoggerE("Error: wrong format: %d \n", entry->format);
+      return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, "Wrong format");
     }
   }
+  return common::PlatformResult(common::ErrorCode::NO_ERROR);
 }
 
-void ExifTagSaver::saveToExif(const std::string& value, ExifTag tag,
-                              ExifData* exif_data, ExifFormat format,
-                              bool add_zero_character) {
+common::PlatformResult ExifTagSaver::saveToExif(const std::string& value, ExifTag tag,
+                                                ExifData* exif_data, ExifFormat format,
+                                                bool add_zero_character) {
   LoggerD("Entered");
   ExifEntry* entry = prepareEntry(exif_data, tag);
   if (!entry) {
-    // TODO return PlatformResult and handle error
     LoggerE("Exif entry is null");
-    return;
+    return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, "Exif entry is null");
   }
 
   if (!value.empty()) {
@@ -106,7 +107,7 @@ void ExifTagSaver::saveToExif(const std::string& value, ExifTag tag,
     entry->data = static_cast<unsigned char*>(malloc(entry->size));
     if (entry->data == nullptr) {
       LoggerE("Function malloc returned nullptr");
-      return;
+      return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, "Function malloc returned nullptr");
     }
 
     memcpy(entry->data, value.c_str(), value.length());
@@ -114,16 +115,16 @@ void ExifTagSaver::saveToExif(const std::string& value, ExifTag tag,
       entry->data[value.length()] = '\0';
     }
   }
+  return common::PlatformResult(common::ErrorCode::NO_ERROR);
 }
 
-void ExifTagSaver::saveToExif(const Rational& value, ExifTag tag,
-                              ExifData* exif_data) {
+common::PlatformResult ExifTagSaver::saveToExif(const Rational& value, ExifTag tag,
+                                                ExifData* exif_data) {
   LoggerD("Entered");
   ExifEntry* entry = prepareEntry(exif_data, tag);
   if (!entry) {
-    // TODO return PlatformResult and handle error
     LoggerE("Exif entry is null");
-    return;
+    return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, "Exif entry is null");
   }
   entry->format = EXIF_FORMAT_RATIONAL;
 
@@ -137,7 +138,7 @@ void ExifTagSaver::saveToExif(const Rational& value, ExifTag tag,
     entry->data = static_cast<unsigned char*>(malloc(entry->size));
     if (entry->data == nullptr) {
       LoggerE("Function malloc returned nullptr");
-      return;
+      return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, "Function malloc returned nullptr");
     }
     memset(entry->data, 0, entry->size);
   }
@@ -149,16 +150,17 @@ void ExifTagSaver::saveToExif(const Rational& value, ExifTag tag,
   r.numerator = value.nominator;
   r.denominator = value.denominator;
   exif_set_rational(entry->data, order, r);
+
+  return common::PlatformResult(common::ErrorCode::NO_ERROR);
 }
 
-void ExifTagSaver::saveToExif(const Rationals& value, ExifTag tag,
+common::PlatformResult ExifTagSaver::saveToExif(const Rationals& value, ExifTag tag,
                               ExifData* exif_data) {
   LoggerD("Entered");
   ExifEntry* entry = prepareEntry(exif_data, tag);
   if (!entry) {
-    // TODO return PlatformResult and handle error
     LoggerE("Exif entry is null");
-    return;
+    return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, "Exif entry is null");
   }
   ExifByteOrder order = exif_data_get_byte_order(exif_data);
   entry->format = EXIF_FORMAT_RATIONAL;
@@ -174,7 +176,7 @@ void ExifTagSaver::saveToExif(const Rationals& value, ExifTag tag,
     entry->data = static_cast<unsigned char*>(malloc(entry->size));
     if (entry->data == nullptr) {
       LoggerE("Function malloc returned nullptr");
-      return;
+      return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, "Function malloc returned nullptr");
     }
     memset(entry->data, 0, entry->size);
   }
@@ -186,17 +188,18 @@ void ExifTagSaver::saveToExif(const Rationals& value, ExifTag tag,
     r.denominator = value[i].denominator;
     exif_set_rational(entry->data + i * ExifTypeInfo::RationalSize, order, r);
   }
+
+  return common::PlatformResult(common::ErrorCode::NO_ERROR);
 }
 
-void ExifTagSaver::saveToExif(std::vector<long long int>& value,
-                              ExifFormat store_as,
-                              ExifTag tag, ExifData* exif_data) {
+common::PlatformResult ExifTagSaver::saveToExif(std::vector<long long int>& value,
+                                                ExifFormat store_as,
+                                                ExifTag tag, ExifData* exif_data) {
   LoggerD("Entered");
   ExifEntry* entry = prepareEntry(exif_data, tag);
   if (!entry) {
-    // TODO return PlatformResult and handle error
     LoggerE("Exif entry is null");
-    return;
+    return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, "Exif entry is null");
   }
   const ExifByteOrder order = exif_data_get_byte_order(exif_data);
 
@@ -210,7 +213,7 @@ void ExifTagSaver::saveToExif(std::vector<long long int>& value,
       break;
     default:
       LoggerE("output ExifFormat: %d is not supported!", store_as);
-      return;
+      return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, "ExifFormat is not supported!");
   }
   entry->format = store_as;
 
@@ -226,7 +229,7 @@ void ExifTagSaver::saveToExif(std::vector<long long int>& value,
     entry->data = static_cast<unsigned char*>(malloc(entry->size));
     if (entry->data == nullptr) {
       LoggerE("Function malloc returned nullptr");
-      return;
+      return common::PlatformResult(common::ErrorCode::UNKNOWN_ERR, "Function malloc returned nullptr");
     }
     memset(entry->data, 0, entry->size);
   }
@@ -272,40 +275,58 @@ void ExifTagSaver::saveToExif(std::vector<long long int>& value,
 
   LoggerD("entry after save:");
   ExifUtil::printExifEntryInfo(entry, exif_data);
+
+  return common::PlatformResult(common::ErrorCode::NO_ERROR);
 }
 
-void ExifTagSaver::saveGpsLocationToExif(const ExifGPSLocation& gps_info,
-                                         ExifData* exif_data) {
+common::PlatformResult ExifTagSaver::saveGpsLocationToExif(const ExifGPSLocation& gps_info,
+                                                           ExifData* exif_data) {
+  common::PlatformResult ret(common::ErrorCode::NO_ERROR);
+
   LoggerD("Entered");
   if (gps_info.isSet(EXIF_GPS_LOCATION_ATTRIBUTE_LATITUDE)) {
     auto latitude = gps_info.getLatitude();
     LoggerD("Saving latitude: %s", latitude.toDebugString().c_str());
-    saveToExif(latitude.toRationalsVector(),
-        static_cast<ExifTag>(EXIF_TAG_GPS_LATITUDE), exif_data);
+    ret = saveToExif(latitude.toRationalsVector(),
+                     static_cast<ExifTag>(EXIF_TAG_GPS_LATITUDE), exif_data);
+    if (!ret) {
+      return ret;
+    }
   }
 
   if (gps_info.isSet(EXIF_GPS_LOCATION_ATTRIBUTE_LATITUDE_REF)) {
     std::string lat_ref =
         (gps_info.getLatitudeRef() == GPS_LOCATION_NORTH) ? "N" : "S";
     LoggerD("Saving latitude ref: %s", lat_ref.c_str());
-    saveToExif(lat_ref, static_cast<ExifTag>(EXIF_TAG_GPS_LATITUDE_REF),
-        exif_data, EXIF_FORMAT_ASCII, false);
+    ret = saveToExif(lat_ref, static_cast<ExifTag>(EXIF_TAG_GPS_LATITUDE_REF),
+                     exif_data, EXIF_FORMAT_ASCII, false);
+    if (!ret) {
+      return ret;
+    }
   }
 
   if (gps_info.isSet(EXIF_GPS_LOCATION_ATTRIBUTE_LONGITUDE)) {
     auto longitude = gps_info.getLongitude();
     LoggerD("Saving longitude: %s", longitude.toDebugString().c_str());
-    saveToExif(longitude.toRationalsVector(),
-        static_cast<ExifTag>(EXIF_TAG_GPS_LONGITUDE), exif_data);
+    ret = saveToExif(longitude.toRationalsVector(),
+                     static_cast<ExifTag>(EXIF_TAG_GPS_LONGITUDE), exif_data);
+    if (!ret) {
+      return ret;
+    }
   }
 
   if (gps_info.isSet(EXIF_GPS_LOCATION_ATTRIBUTE_LONGITUDE_REF)) {
     std::string long_ref =
         (gps_info.getLongitudeRef() == GPS_LOCATION_WEST) ? "W" : "E";
     LoggerD("Saving longitude ref: %s", long_ref.c_str());
-    saveToExif(long_ref, static_cast<ExifTag>(EXIF_TAG_GPS_LONGITUDE_REF),
-        exif_data, EXIF_FORMAT_ASCII, false);
+    ret = saveToExif(long_ref, static_cast<ExifTag>(EXIF_TAG_GPS_LONGITUDE_REF),
+                     exif_data, EXIF_FORMAT_ASCII, false);
+    if (!ret) {
+      return ret;
+    }
   }
+
+  return ret;
 }
 
 ExifEntry* ExifTagSaver::prepareEntry(ExifData* exif_data, ExifTag tag) {
@@ -357,8 +378,6 @@ ExifEntry* ExifTagSaver::createNewTag(ExifData* exif_data, ExifIfd ifd,
 
 common::PlatformResult ExifTagSaver::deduceIfdSection(ExifTag tag, ExifIfd* exif_ifd) {
   LoggerD("Entered");
-  // TODO EXIF_TAG_* and EXIF_TAG_GPS_* are sharing same values,
-  // they shouldn't be used in one switch statement.
 
   switch (static_cast<unsigned int>(tag)) {
     // Tags in IFD_0 Section
@@ -407,8 +426,6 @@ common::PlatformResult ExifTagSaver::deduceIfdSection(ExifTag tag, ExifIfd* exif
 
 common::PlatformResult ExifTagSaver::deduceDataFormat(ExifTag tag, ExifFormat* exif_format) {
   LoggerD("Entered");
-  // TODO EXIF_TAG_* and EXIF_TAG_GPS_* are sharing same values,
-  // they shouldn't be used in one switch statement.
 
   switch (static_cast<unsigned int>(tag)) {
     // Tags with byte type:

diff --git a/src/exif/exif_tag_saver.h b/src/exif/exif_tag_saver.h
index 1120fd5..ba13eb2 100755 (executable)
--- a/src/exif/exif_tag_saver.h
+++ b/src/exif/exif_tag_saver.h
@@ -32,17 +32,17 @@ class ExifTagSaver {
  public:
   static void removeExifEntryWithTag(const ExifTag tag, ExifData* exif_data);
 
-  static void saveToExif(long int value, ExifTag tag, ExifData* exif_data);
-  static void saveToExif(const std::string& value, ExifTag tag,
+  static common::PlatformResult saveToExif(long int value, ExifTag tag, ExifData* exif_data);
+  static common::PlatformResult saveToExif(const std::string& value, ExifTag tag,
       ExifData* exif_data, ExifFormat format = EXIF_FORMAT_ASCII,
       bool add_zero_character = true);
-  static void saveToExif(const Rational& value, ExifTag tag,
+  static common::PlatformResult saveToExif(const Rational& value, ExifTag tag,
       ExifData* exif_data);
-  static void saveToExif(const Rationals& value, ExifTag tag,
+  static common::PlatformResult saveToExif(const Rationals& value, ExifTag tag,
       ExifData* exif_data);
-  static void saveToExif(std::vector<long long int>& value, ExifFormat store_as,
+  static common::PlatformResult saveToExif(std::vector<long long int>& value, ExifFormat store_as,
       ExifTag tag, ExifData* exif_data);
-  static void saveGpsLocationToExif(const ExifGPSLocation& gps_info,
+  static common::PlatformResult saveGpsLocationToExif(const ExifGPSLocation& gps_info,
       ExifData* exif_data);
 
  private:

diff --git a/src/exif/get_exif_info.cc b/src/exif/get_exif_info.cc
index d710e40..5092a5e 100755 (executable)
--- a/src/exif/get_exif_info.cc
+++ b/src/exif/get_exif_info.cc
@@ -499,7 +499,6 @@ void GetExifInfo::DataForeachFunction(ExifContent *content, void *user_data) {
 PlatformResult GetExifInfo::LoadFromURI(const std::string& uri,
                                         JsonValue* result) {
   LoggerD("Entered");
-  // TODO(r.galka) it can be done on JS side
   const std::string& file_path = ExifUtil::convertUriToPath(uri);
   ExifData* ed = exif_data_new_from_file(file_path.c_str());
   if (!ed) {

diff --git a/src/exif/jpeg_file.cc b/src/exif/jpeg_file.cc
index c5285d8..b8c6f25 100755 (executable)
--- a/src/exif/jpeg_file.cc
+++ b/src/exif/jpeg_file.cc
@@ -332,10 +332,6 @@ common::PlatformResult JpegFile::generateListOfSections() {
       }
 
       if (JPEG_MARKER_APP1 == cur_marker) {
-        // TODO(Unknown): verify this
-        // -4 --> 0xFF(1 byte)+Marker Number(1 byte)+Data size(2 bytes))
-        // const unsigned int exif_data_size = section_length - 4;
-
         const unsigned int exif_data_size = total_section_len + 2;
         section->exif_data = exif_data_new_from_data(section_begin,
             exif_data_size);

diff --git a/src/utils/utils_api.js b/src/utils/utils_api.js
index dc70f76..b7534b3 100755 (executable)
--- a/src/utils/utils_api.js
+++ b/src/utils/utils_api.js
@@ -409,6 +409,22 @@ Converter.prototype.toUnsignedLongLong = function(val, nullable) {
   return _nullableGeneric(_toUnsignedLongLong, nullable, val);
 };
 
+function _toShort(val) {
+  return ((_toLong(val) + 32768) & 0xFFFF) - 32768;
+}
+
+Converter.prototype.toShort = function(val, nullable) {
+  return _nullableGeneric(_toShort, nullable, val);
+};
+
+function _toUnsignedShort(val) {
+  return (Math.abs(_toLong(val)) & 0xFFFF);
+}
+
+Converter.prototype.toUnsignedShort = function(val, nullable) {
+  return _nullableGeneric(_toUnsignedShort, nullable, val);
+};
+
 function _toByte(val) {
   return ((_toLong(val) + 128) & 0xFF) - 128;
 }