Bugfix/fix reuse last entered value

app/android/src/uk/co/lutraconsulting/MMActivity.java

@@ -201,6 +201,7 @@ public String importImage(Uri imageUri, String targetPath) {
     String fileName = getFileName( imageUri );
     File newCopyFile = new File( targetPath + "/" + fileName );
     try {
+      newCopyFile.getParentFile().mkdirs();
       newCopyFile.createNewFile();
       InputStream fileStream = getContentResolver().openInputStream( imageUri );
       copyFile( fileStream, newCopyFile );

app/attributes/attributecontroller.cpp

@@ -612,7 +612,8 @@ void AttributeController::updateOnFeatureChange()
       const QVariant newVal = feature.attribute( fieldIndex );
       mFormItems[itemData->id()]->setOriginalValue( newVal );
       mFormItems[itemData->id()]->setRawValue( newVal ); // we need to set raw value as well, as we use it in form now
-      if ( mRememberAttributesController && isNewFeature() ) // this is a new feature
+      mFormItems[itemData->id()]->setReusedValue( false );
+      if ( mRememberAttributesController && isNewFeature() && newVal.toString().isEmpty() )
       {
         QVariant rememberedValue;
         bool shouldUseRememberedValue = mRememberAttributesController->rememberedValue(
@@ -622,8 +623,36 @@ void AttributeController::updateOnFeatureChange()
                                         );
         if ( shouldUseRememberedValue )
         {
-          mFeatureLayerPair.featureRef().setAttribute( fieldIndex, rememberedValue );
-          itemData->setRawValue( rememberedValue );
+          QVariant valueToUse = rememberedValue;
+
+          if ( itemData->editorWidgetType() == QStringLiteral( "ExternalResource" ) && !rememberedValue.toString().isEmpty() )
+          {
+            const QVariantMap config = itemData->editorWidgetConfig();
+            const FeatureLayerPair parentPair = mParentController ? mParentController->featureLayerPair() : FeatureLayerPair();
+            const QString targetDir = InputUtils::resolveTargetDir( QgsProject::instance()->homePath(), config, mFeatureLayerPair, parentPair, QgsProject::instance() );
+            const QString prefix = InputUtils::resolvePrefixForRelativePath( config[ QStringLiteral( "RelativeStorage" ) ].toInt(), QgsProject::instance()->homePath(), targetDir );
+            const QString src = InputUtils::getAbsolutePath( rememberedValue.toString(), prefix );
+            const QFileInfo fi( src );
+
+            static const QRegularExpression trailingCounter( QStringLiteral( "\\s\\(\\d+\\)$" ) );
+            QString baseName = fi.completeBaseName();
+            baseName.remove( trailingCounter );
+            const QString canonicalName = fi.suffix().isEmpty() ? baseName : QStringLiteral( "%1.%2" ).arg( baseName, fi.suffix() );
+
+            const QString dst = CoreUtils::findUniquePath( InputUtils::getAbsolutePath( canonicalName, targetDir ), true );
+
+            if ( InputUtils::copyFile( src, dst ) )
+            {
+              valueToUse = InputUtils::getRelativePath( dst, prefix );
+              itemData->setReusedCopyPath( dst );
+            }
+          }
+
+          mFeatureLayerPair.featureRef().setAttribute( fieldIndex, valueToUse );
+          itemData->setRawValue( valueToUse );
+          itemData->setOriginalValue( valueToUse );
+          // an empty value means there's nothing to reuse, so don't mark it as such
+          itemData->setReusedValue( !valueToUse.toString().isEmpty() );
         }
       }
     }
@@ -789,9 +818,11 @@ void AttributeController::recalculateDefaultValues(
     const QgsField field = item->field();
     const QgsDefaultValue defaultDefinition = field.defaultValueDefinition();
 
+    // don't let a Default Value expression overwrite a value we just reused
     bool shouldApplyDefaultValue =
       !defaultDefinition.expression().isEmpty() &&
-      ( isFirstUpdateOfNewFeature || ( isFormValueChange && defaultDefinition.applyOnUpdate() ) );
+      ( isFirstUpdateOfNewFeature || ( isFormValueChange && defaultDefinition.applyOnUpdate() ) ) &&
+      !item->isReusedValue();
 
     if ( shouldApplyDefaultValue )
     {
@@ -1211,6 +1242,8 @@ bool AttributeController::deleteFeature()
 
 bool AttributeController::rollback()
 {
+  discardReusedPhotoCopies( true );
+
   if ( !mFeatureLayerPair.layer() )
     return false;
 
@@ -1293,6 +1326,12 @@ bool AttributeController::save()
     disconnect( mFeatureLayerPair.layer(), &QgsVectorLayer::featureAdded, this, &AttributeController::onFeatureAdded );
   }
 
+  if ( rv )
+  {
+    // catches a reused copy that got deleted/replaced before save
+    discardReusedPhotoCopies( false );
+  }
+
   // Store the feature attributes for future use
   if ( featureIsNew && mRememberAttributesController )
   {
@@ -1497,6 +1536,7 @@ bool AttributeController::setFormValue( const QUuid &id, QVariant value )
     QgsField field = item->field();
     QVariant val( value );
 
+    item->setReusedValue( false );
     item->setRawValue( val );
     emit formDataChanged( item->id(), { AttributeFormModel::RawValue } );
 
@@ -1576,6 +1616,27 @@ void AttributeController::onFeatureAdded( QgsFeatureId newFeatureId )
   emit featureIdChanged();
 }
 
+void AttributeController::discardReusedPhotoCopies( bool force )
+{
+  QMap<QUuid, std::shared_ptr<FormItem>>::const_iterator formItemsIterator = mFormItems.constBegin();
+  while ( formItemsIterator != mFormItems.constEnd() )
+  {
+    std::shared_ptr<FormItem> item = formItemsIterator.value();
+    const QString copyPath = item->reusedCopyPath();
+    if ( !copyPath.isEmpty() )
+    {
+      // isReusedValue() is cleared as soon as the field changes, so it already tells
+      // whether the copy is still the field's current value
+      if ( force || !item->isReusedValue() )
+      {
+        InputUtils::removeFile( copyPath );
+      }
+      item->setReusedCopyPath( QString() );
+    }
+    ++formItemsIterator;
+  }
+}
+
 void AttributeController::renamePhotos()
 {
   const QStringList photoNameFormat = QgsProject::instance()->entryList( QStringLiteral( "Mergin" ), QStringLiteral( "PhotoNaming/%1" ).arg( mFeatureLayerPair.layer()->id() ) );
@@ -1608,7 +1669,7 @@ void AttributeController::renamePhotos()
         continue;
       }
 
-      if ( item->originalValue() != mFeatureLayerPair.feature().attribute( item->fieldIndex() ) )
+      if ( item->isReusedValue() || item->originalValue() != mFeatureLayerPair.feature().attribute( item->fieldIndex() ) )
       {
         const QString expString = QgsProject::instance()->readEntry( QStringLiteral( "Mergin" ), QStringLiteral( "PhotoNaming/%1/%2" ).arg( mFeatureLayerPair.layer()->id(), field.name() ) );
         QgsExpression exp( expString );
@@ -1649,13 +1710,18 @@ void AttributeController::renamePhotos()
         InputUtils::sanitizePath( newName );
 
         const QFileInfo fi( src );
-        newName = QStringLiteral( "%1.%2" ).arg( newName, fi.completeSuffix() );
+        newName = QStringLiteral( "%1.%2" ).arg( newName, fi.suffix() );
 
-        const QString dst = CoreUtils::findUniquePath( InputUtils::getAbsolutePath( newName, targetDir ) );
+        const QString dst = CoreUtils::findUniquePath( InputUtils::getAbsolutePath( newName, targetDir ), true );
         if ( InputUtils::renameFile( src, dst ) )
         {
           const QString newValue = InputUtils::getRelativePath( dst, prefix );
           setFormValue( item->id(), newValue );
+          // keep originalValue() in sync so this doesn't get renamed again on the next save
+          item->setOriginalValue( newValue );
+          // only clear if we actually renamed the tracked clone, not a replacement photo
+          if ( src == item->reusedCopyPath() )
+            item->setReusedCopyPath( QString() );
           expressionContext.setFeature( featureLayerPair().featureRef() );
         }
         else

app/attributes/attributecontroller.h

@@ -222,6 +222,7 @@ class  AttributeController : public QObject
      */
     bool allowTabs( QgsAttributeEditorContainer *container );
 
+    void discardReusedPhotoCopies( bool force );
     //! renames photos if necessary
     void renamePhotos();
     //! save temporary sketched image to original image

app/attributes/attributedata.cpp

@@ -300,6 +300,26 @@ void FormItem::setOriginalValue( const QVariant &originalValue )
   mOriginalValue = originalValue;
 }
 
+bool FormItem::isReusedValue() const
+{
+  return mIsReusedValue;
+}
+
+void FormItem::setReusedValue( bool reused )
+{
+  mIsReusedValue = reused;
+}
+
+QString FormItem::reusedCopyPath() const
+{
+  return mReusedCopyPath;
+}
+
+void FormItem::setReusedCopyPath( const QString &path )
+{
+  mReusedCopyPath = path;
+}
+
 QgsRelation FormItem::relation() const
 {
   return mRelation;

app/attributes/attributedata.h

@@ -152,6 +152,12 @@ class FormItem
     QVariant rawValue() const;
     void setRawValue( const QVariant &rawValue );
 
+    bool isReusedValue() const;
+    void setReusedValue( bool reused );
+
+    QString reusedCopyPath() const;
+    void setReusedCopyPath( const QString &path );
+
     QgsRelation relation() const;
     QString fieldError() const;
 
@@ -178,6 +184,8 @@ class FormItem
     bool mVisible = false;
     QVariant mOriginalValue; // original unmodified value
     QVariant mRawValue;
+    bool mIsReusedValue = false;
+    QString mReusedCopyPath;
 
     const QgsRelation mRelation; // Only used for FormItemType::Relation
 };

app/inpututils.cpp

@@ -1018,6 +1018,8 @@ QString InputUtils::resolveTargetDir( const QString &homePath, const QVariantMap
   {
     QString result = evaluateExpression( pair, parentPair, activeProject, expression );
     sanitizePath( result );
+    if ( !result.isEmpty() && !QDir::isAbsolutePath( result ) )
+      result = QDir( homePath ).absoluteFilePath( result );
     return result;
   }
   else
@@ -1029,6 +1031,8 @@ QString InputUtils::resolveTargetDir( const QString &homePath, const QVariantMap
     }
     else
     {
+      if ( !QDir::isAbsolutePath( defaultRoot ) )
+        defaultRoot = QDir( homePath ).absoluteFilePath( defaultRoot );
       return defaultRoot;
     }
   }

app/ios/iosviewdelegate.mm

@@ -94,6 +94,8 @@ - ( void )picker:( PHPickerViewController * )picker didFinishPicking:( NSArray<P
     BOOL writeSuccess = NO;
     if ( url && !error )
     {
+      [[NSFileManager defaultManager] createDirectoryAtPath:targetDir withIntermediateDirectories:YES attributes:nil error:nil];
+
       NSError *copyError = nil;
       [[NSFileManager defaultManager] copyItemAtURL:url toURL:[NSURL fileURLWithPath:imagePath] error:&copyError];
       writeSuccess = ( copyError == nil );