status-im/status-go

package protocol

import (
    "context"
    "encoding/json"

    "go.uber.org/zap"

    gocommon "github.com/status-im/status-go/common"
    "github.com/status-im/status-go/multiaccounts/errors"
    "github.com/status-im/status-go/multiaccounts/settings"
    "github.com/status-im/status-go/protocol/common"
    "github.com/status-im/status-go/protocol/protobuf"
)

// syncSettings syncs all settings that are syncable
func (m *Messenger) prepareSyncSettingsMessages(currentClock uint64, prepareForBackup bool) (resultRaw []*common.RawMessage, resultSync []*protobuf.SyncSetting, errors []error) {
    s, err := m.settings.GetSettings()
    if err != nil {
        errors = append(errors, err)
        return
    }

    logger := m.logger.Named("prepareSyncSettings")
    // Do not use the network clock, use the db value
    _, chat := m.getLastClockWithRelatedChat()

    for _, sf := range settings.SettingFieldRegister {
        if sf.CanSync(settings.FromStruct) {
            // DisplayName is backed up via `protobuf.BackedUpProfile` message.
            if prepareForBackup && sf.SyncProtobufFactory().SyncSettingProtobufType() == protobuf.SyncSetting_DISPLAY_NAME {
                continue
            }

            // Pull clock from the db
            clock, err := m.settings.GetSettingLastSynced(sf)
            if err != nil {
                logger.Error("m.settings.GetSettingLastSynced", zap.Error(err), zap.Any("SettingField", sf))
                errors = append(errors, err)
                return
            }
            if clock == 0 {
                clock = currentClock
            }

            // Build protobuf
            rm, sm, err := sf.SyncProtobufFactory().FromStruct()(s, clock, chat.ID)
            if err != nil {
                // Collect errors to give other sync messages a chance to send
                logger.Error("SyncProtobufFactory.Struct", zap.Error(err))
                errors = append(errors, err)
            }

            resultRaw = append(resultRaw, rm)
            resultSync = append(resultSync, sm)
        }
    }
    return
}

func (m *Messenger) syncSettings(rawMessageHandler RawMessageHandler) error {
    logger := m.logger.Named("syncSettings")

    clock, _ := m.getLastClockWithRelatedChat()
    rawMessages, _, errors := m.prepareSyncSettingsMessages(clock, false)

    if len(errors) != 0 {
        // return just the first error, the others have been logged
        return errors[0]
    }

    for _, rm := range rawMessages {
        _, err := rawMessageHandler(context.Background(), *rm)
        if err != nil {
            logger.Error("dispatchMessage", zap.Error(err))
            return err
        }
        logger.Debug("dispatchMessage success", zap.Any("rm", rm))
    }

    return nil
}

// extractSyncSetting parses incoming *protobuf.SyncSetting and stores the setting data if needed
func (m *Messenger) extractAndSaveSyncSetting(syncSetting *protobuf.SyncSetting) (*settings.SyncSettingField, error) {
    sf, err := settings.GetFieldFromProtobufType(syncSetting.Type)
    if err != nil {
        m.logger.Error(
            "extractSyncSetting - settings.GetFieldFromProtobufType",
            zap.Error(err),
            zap.Any("syncSetting", syncSetting),
        )
        return nil, err
    }

    spf := sf.SyncProtobufFactory()
    if spf == nil {
        m.logger.Warn("extractSyncSetting - received protobuf for setting with no SyncProtobufFactory", zap.Any("SettingField", sf))
        return nil, nil
    }
    if spf.Inactive() {
        m.logger.Warn("extractSyncSetting - received protobuf for inactive sync setting", zap.Any("SettingField", sf))
        return nil, nil
    }

    value := spf.ExtractValueFromProtobuf()(syncSetting)

    err = m.settings.SaveSyncSetting(sf, value, syncSetting.Clock)
    if err == errors.ErrNewClockOlderThanCurrent {
        m.logger.Info("extractSyncSetting - SaveSyncSetting :", zap.Error(err))
        return nil, nil
    }
    if err != nil {
        return nil, err
    }

    if v, ok := value.([]byte); ok {
        value = json.RawMessage(v)
    }

    return &settings.SyncSettingField{SettingField: sf, Value: value}, nil
}

// startSyncSettingsLoop watches the m.settings.SyncQueue and sends a sync message in response to a settings update
func (m *Messenger) startSyncSettingsLoop() {
    go func() {
        defer gocommon.LogOnPanic()
        logger := m.logger.Named("SyncSettingsLoop")

        for {
            select {
            case s := <-m.settings.GetSyncQueue():
                if s.CanSync(settings.FromInterface) {
                    logger.Debug("setting for sync received from settings.SyncQueue")

                    clock, chat := m.getLastClockWithRelatedChat()

                    // Only the messenger has access to the clock, so set the settings sync clock here.
                    err := m.settings.SetSettingLastSynced(s.SettingField, clock)
                    if err != nil {
                        logger.Error("m.settings.SetSettingLastSynced", zap.Error(err))
                        break
                    }
                    rm, _, err := s.SyncProtobufFactory().FromInterface()(s.Value, clock, chat.ID)
                    if err != nil {
                        logger.Error("SyncProtobufFactory().FromInterface", zap.Error(err), zap.Any("SyncSettingField", s))
                        break
                    }

                    _, err = m.dispatchMessage(context.Background(), *rm)
                    if err != nil {
                        logger.Error("dispatchMessage", zap.Error(err))
                        break
                    }

                    logger.Debug("message dispatched")
                }
            case <-m.quit:
                return
            }
        }
    }()
}

func (m *Messenger) startSettingsChangesLoop() {
    channel := m.settings.SubscribeToChanges()
    go func() {
        defer gocommon.LogOnPanic()
        for {
            select {
            case s := <-channel:
                switch s.GetReactName() {
                case settings.DisplayName.GetReactName():
                    m.selfContact.DisplayName = s.Value.(string)
                    m.publishSelfContactSubscriptions(&SelfContactChangeEvent{DisplayNameChanged: true})
                case settings.PreferredName.GetReactName():
                    m.selfContact.EnsName = s.Value.(string)
                    m.publishSelfContactSubscriptions(&SelfContactChangeEvent{PreferredNameChanged: true})
                case settings.Bio.GetReactName():
                    m.selfContact.Bio = s.Value.(string)
                    m.publishSelfContactSubscriptions(&SelfContactChangeEvent{BioChanged: true})
                }
            case <-m.quit:
                return
            }
        }
    }()
}