Add & Remove Reactions

Enable users to express emotions and engage with content through comprehensive reaction management. Build expressive communities where users can add, modify, and remove reactions on posts, stories, comments, and messages with real-time synchronization.

Architecture Overview

Key Features

Multi-Content Reactions

Add reactions to posts, stories, comments, and messages

Real-time Updates

Instant reaction synchronization across all clients

Flexible Reaction Types

Support unlimited custom reaction types up to 100 characters

Optimistic Updates

Immediate UI feedback with automatic error handling

Add Reaction

Enable users to express emotions and engagement through reactions. The addReaction function provides comprehensive support for all content types with real-time synchronization and optimistic UI updates.

Parameters

reactionName

Type: stringRequired: YesDescription: Name of the reaction to add. Case-sensitive with maximum length of 100 characters.Examples: "like", "love", "wow", "celebrate", "support"Validation:

Maximum 100 characters
Case-sensitive (“like” ≠ “Like”)
Alphanumeric and special characters allowed

referenceType

Type: ReactionReferenceTypeRequired: YesDescription: Specifies the type of content to react to.Valid Values:

POST - React to posts in feeds and communities
STORY - React to ephemeral story content
COMMENT - React to comments in discussions
MESSAGE - React to messages in chats

referenceId

Type: stringRequired: YesDescription: Unique identifier of the content to react to. Must correspond to existing content of the specified reference type.

callback

Type: FunctionRequired: No (varies by platform)Description: Optional callback function to handle success/error responses. Returns reaction data on success.

Implementation

iOS
Android
TypeScript
Flutter

import AmitySDK

class ReactionManager {
    private let reactionRepository: AmityReactionRepository
    
    init(client: Client) {
        self.reactionRepository = AmityReactionRepository(client: client)
    }
    
    func addReaction(
        reactionName: String,
        referenceType: AmityReactionReferenceType,
        referenceId: String,
        completion: @escaping (Result<AmityReaction, Error>) -> Void
    ) {
        reactionRepository.addReaction(
            reactionName,
            referenceType: referenceType,
            referenceId: referenceId
        ) { [weak self] success, error in
            if success {
                print("Reaction '\(reactionName)' added successfully")
                self?.trackReactionAdded(reactionName: reactionName, referenceType: referenceType)
                completion(.success(success))
            } else {
                print("Failed to add reaction: \(error?.localizedDescription ?? "Unknown error")")
                completion(.failure(error ?? ReactionError.unknown))
            }
        }
    }
    
    private func trackReactionAdded(reactionName: String, referenceType: AmityReactionReferenceType) {
        // Analytics tracking
        AnalyticsManager.shared.track("reaction_added", parameters: [
            "reaction_name": reactionName,
            "reference_type": referenceType.rawValue,
            "timestamp": Date().timeIntervalSince1970
        ])
    }
}

import com.amity.socialcloud.sdk.social.reaction.*

class ReactionManager(private val client: Client) {
    private val reactionRepository = AmityReactionRepository(client)
    
    fun addReaction(
        reactionName: String,
        referenceType: AmityReactionReferenceType,
        referenceId: String,
        callback: (Result<AmityReaction>) -> Unit
    ) {
        reactionRepository.addReaction(reactionName, referenceType, referenceId)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(
                { reaction ->
                    println("Reaction '$reactionName' added successfully")
                    trackReactionAdded(reactionName, referenceType)
                    callback(Result.success(reaction))
                },
                { error ->
                    println("Failed to add reaction: ${error.message}")
                    callback(Result.failure(RuntimeException(error)))
                }
            )
    }
    
    private fun trackReactionAdded(
        reactionName: String, 
        referenceType: AmityReactionReferenceType
    ) {
        AnalyticsManager.track("reaction_added", mapOf(
            "reaction_name" to reactionName,
            "reference_type" to referenceType.name,
            "timestamp" to System.currentTimeMillis()
        ))
    }
}

class ReactionManager {
    private client: SocialClient;
    
    constructor(client: SocialClient) {
        this.client = client;
    }
    
    async addReaction(
        reactionName: string,
        referenceType: ReactionReferenceType,
        referenceId: string
    ): Promise<Amity.Reaction> {
        try {
            const reaction = await this.client.addReaction(
                reactionName,
                referenceType,
                referenceId
            );
            
            console.log(`Amity.Reaction '${reactionName}' added successfully`);
            this.trackReactionAdded(reactionName, referenceType);
            
            return reaction;
        } catch (error) {
            console.error('Failed to add reaction:', error);
            throw error;
        }
    }
    
    private trackReactionAdded(
        reactionName: string, 
        referenceType: ReactionReferenceType
    ): void {
        if (typeof window !== 'undefined' && window.analytics) {
            window.analytics.track('Amity.Reaction Added', {
                reactionName,
                referenceType,
                timestamp: Date.now()
            });
        }
    }
}

import 'package:amity_sdk/amity_sdk.dart';

class ReactionManager {
  Future<AmityReaction> addReaction({
    required String reactionName,
    required AmityReactionReferenceType referenceType,
    required String referenceId,
  }) async {
    try {
      final reaction = await AmityReactionRepository()
          .addReaction(reactionName, referenceType, referenceId);
      
      print('Reaction \'$reactionName\' added successfully');
      _trackReactionAdded(reactionName, referenceType);
      
      return reaction;
    } catch (error) {
      print('Failed to add reaction: $error');
      rethrow;
    }
  }
  
  void _trackReactionAdded(
    String reactionName,
    AmityReactionReferenceType referenceType,
  ) {
    // Analytics tracking
    AnalyticsManager.track('reaction_added', {
      'reaction_name': reactionName,
      'reference_type': referenceType.name,
      'timestamp': DateTime.now().millisecondsSinceEpoch,
    });
  }
}

Remove Reaction

The removeReaction function allows users to remove a previously added reaction from content. This provides users with greater control over their engagement and allows them to change their minds or update their reactions over time.

Architecture

Features

Instant Removal

Remove reactions immediately with real-time updates

Reference Support

Remove reactions from posts, stories, comments, and messages

Analytics Tracking

Track removal patterns and user engagement metrics

Error Handling

Comprehensive validation and error management

Parameters

reactionName

Type: stringRequired: YesDescription: The name of the reaction to remove. Names are case-sensitive (e.g., “like” vs “Like” are different reactions).Example: "like", "love", "angry"

referenceType

Type: ReactionReferenceTypeRequired: YesDescription: Specifies the type of content to remove reaction from.Valid Values:

POST - Remove reaction from posts
STORY - Remove reaction from story content
COMMENT - Remove reaction from comments
MESSAGE - Remove reaction from messages

referenceId

Type: stringRequired: YesDescription: Unique identifier of the content to remove reaction from.

Implementation

iOS
Android
TypeScript
Flutter

import AmitySDK

class ReactionManager {
    private let reactionRepository: AmityReactionRepository
    
    init(client: Client) {
        self.reactionRepository = AmityReactionRepository(client: client)
    }
    
    func removeReaction(
        reactionName: String,
        referenceType: AmityReactionReferenceType,
        referenceId: String,
        completion: @escaping (Result<Bool, Error>) -> Void
    ) {
        reactionRepository.removeReaction(
            reactionName,
            referenceType: referenceType,
            referenceId: referenceId
        ) { [weak self] success, error in
            if success {
                print("Reaction '\(reactionName)' removed successfully")
                self?.trackReactionRemoved(reactionName: reactionName, referenceType: referenceType)
                completion(.success(true))
            } else {
                print("Failed to remove reaction: \(error?.localizedDescription ?? "Unknown error")")
                completion(.failure(error ?? ReactionError.unknown))
            }
        }
    }
    
    private func trackReactionRemoved(reactionName: String, referenceType: AmityReactionReferenceType) {
        AnalyticsManager.shared.track("reaction_removed", parameters: [
            "reaction_name": reactionName,
            "reference_type": referenceType.rawValue,
            "timestamp": Date().timeIntervalSince1970
        ])
    }
}

import com.amity.socialcloud.sdk.AmityClient
import com.amity.socialcloud.sdk.model.social.reaction.AmityReactionRepository
import com.amity.socialcloud.sdk.model.social.reaction.AmityReactionReferenceType

class ReactionManager(private val client: Client) {
    private val reactionRepository = AmityReactionRepository(client)
    
    fun removeReaction(
        reactionName: String,
        referenceType: AmityReactionReferenceType,
        referenceId: String
    ): Completable {
        return reactionRepository.removeReaction(reactionName, referenceType, referenceId)
            .doOnComplete {
                Log.d("ReactionManager", "Reaction '$reactionName' removed successfully")
                trackReactionRemoved(reactionName, referenceType)
            }
            .doOnError { error ->
                Log.e("ReactionManager", "Failed to remove reaction: ${error.message}")
            }
    }
    
    private fun trackReactionRemoved(reactionName: String, referenceType: AmityReactionReferenceType) {
        AnalyticsManager.track("reaction_removed", mapOf(
            "reaction_name" to reactionName,
            "reference_type" to referenceType.name,
            "timestamp" to System.currentTimeMillis()
        ))
    }
}

import { Client } from '@amityco/ts-sdk';

class ReactionManager {
    constructor(private client: Client) {}
    
    async removeReaction(
        reactionName: string,
        referenceType: ReactionReferenceType,
        referenceId: string
    ): Promise<boolean> {
        try {
            const result = await this.client.removeReaction(
                reactionName,
                referenceType,
                referenceId
            );
            
            console.log(`Amity.Reaction '${reactionName}' removed successfully`);
            this.trackReactionRemoved(reactionName, referenceType);
            
            return result;
        } catch (error) {
            console.error('Failed to remove reaction:', error);
            throw error;
        }
    }
    
    private trackReactionRemoved(reactionName: string, referenceType: ReactionReferenceType): void {
        // Analytics tracking
        analytics.track('reaction_removed', {
            reaction_name: reactionName,
            reference_type: referenceType,
            timestamp: Date.now()
        });
    }
}

import 'package:amity_sdk/amity_sdk.dart';

class ReactionManager {
    
    Future<void> removeReaction({
        required String reactionName,
        required String referenceType,
        required String referenceId,
    }) async {
        try {
            // Remove reaction based on reference type
            switch (referenceType.toLowerCase()) {
                case 'post':
                    await AmityReaction.removePostReaction(
                        postId: referenceId,
                        reactionName: reactionName,
                    );
                    break;
                case 'comment':
                    await AmityReaction.removeCommentReaction(
                        commentId: referenceId,
                        reactionName: reactionName,
                    );
                    break;
                case 'story':
                    await AmityReaction.removeStoryReaction(
                        storyId: referenceId,
                        reactionName: reactionName,
                    );
                    break;
                case 'message':
                    await AmityReaction.removeMessageReaction(
                        messageId: referenceId,
                        reactionName: reactionName,
                    );
                    break;
                default:
                    throw ArgumentError('Unsupported reference type: $referenceType');
            }
            
            print('Reaction "$reactionName" removed successfully');
            _trackReactionRemoved(reactionName, referenceType);
        } catch (error) {
            print('Failed to remove reaction: $error');
            rethrow;
        }
    }
    
    void _trackReactionRemoved(String reactionName, String referenceType) {
        // Analytics tracking
        AnalyticsManager.track('reaction_removed', {
            'reaction_name': reactionName,
            'reference_type': referenceType,
            'timestamp': DateTime.now().millisecondsSinceEpoch,
        });
    }
}

Best Practices

Optimistic Updates

Update UI immediately while processing the reaction in the background for better user experience.

Error Handling

Always implement proper error handling and provide user feedback for failed operations.

State Management

Maintain local reaction state to prevent duplicate operations and enable offline functionality.

Analytics Tracking

Track reaction patterns to understand user engagement and improve content strategy.

Implementation Guidelines

Validation and Error Handling

Always validate reaction names and reference IDs before making API calls
Implement proper error handling for network failures and invalid requests
Provide meaningful error messages to users
Use try-catch blocks to handle exceptions gracefully

Performance Optimization

Implement caching to track existing reactions and prevent redundant API calls
Use debouncing for rapid add/remove operations
Consider implementing offline support with sync when connection is restored
Batch multiple reaction operations when possible

User Experience

Provide immediate visual feedback when reactions are added or removed
Show loading states during API operations
Handle edge cases like network failures gracefully
Allow users to undo reaction changes within a reasonable time window

Analytics and Monitoring

Track reaction addition and removal events for engagement analysis
Monitor API response times and error rates
Log user interaction patterns to improve UX
Implement A/B testing for different reaction UI designs

Use Cases

Error Handling

Common Error Types

Network Errors: Handle offline scenarios and poor connectivity
Validation Errors: Invalid reaction names or reference IDs
Permission Errors: User lacks permission to react to content
Rate Limiting: Too many reactions added/removed too quickly

Error Response Examples

{
  "error": {
    "code": "REACTION_NOT_FOUND",
    "message": "The specified reaction does not exist",
    "details": {
      "reactionName": "like",
      "referenceId": "post_123"
    }
  }
}

Recovery Strategies

Implement retry logic with exponential backoff
Provide fallback UI states for failed operations
Cache operations for offline execution when connection is restored
Show appropriate error messages based on error type

Documentation Index

​Add & Remove Reactions

​Architecture Overview

​Key Features

Multi-Content Reactions

Real-time Updates

Flexible Reaction Types

Optimistic Updates

​Add Reaction

​Parameters

​Implementation

​Remove Reaction

​Architecture

​Features

Instant Removal

Reference Support

Analytics Tracking

Error Handling

​Parameters

​Implementation

​Best Practices

Optimistic Updates

Error Handling

State Management

Analytics Tracking

​Implementation Guidelines

​Use Cases

​Error Handling

Add & Remove Reactions

Architecture Overview

Key Features

Add Reaction

Parameters

Implementation

Remove Reaction

Architecture

Features

Parameters

Implementation

Best Practices

Implementation Guidelines

Use Cases

Error Handling