mc5-api-client 1.0.16__py3-none-any.whl → 1.0.17__py3-none-any.whl

mc5_api_client/client.py

@@ -13,12 +13,20 @@ import time
 import json
 from typing import Optional, Dict, Any, List
 from datetime import datetime
+from urllib.parse import quote
 
 import requests
 from requests.adapters import HTTPAdapter
 from urllib3.util.retry import Retry
 
 from .auth import TokenGenerator
+from .telemetry import telemetry, report_error, report_usage, is_telemetry_enabled
+from .squad_battle import SquadBattleMixin
+from .federation import FederationMixin
+from .alerts import AlertsMixin
+from .account import AccountMixin
+from .transfer import TransferMixin
+from .platform import Platform, get_platform_config, detect_platform_from_client_id
 from .exceptions import (
     MC5APIError,
     AuthenticationError,
@@ -29,7 +37,7 @@ from .exceptions import (
 )
 
 
-class MC5Client:
+class MC5Client(SquadBattleMixin, FederationMixin, AlertsMixin, AccountMixin, TransferMixin):
     """
     Comprehensive MC5 API client with support for all major endpoints.
     """
@@ -42,15 +50,18 @@ class MC5Client:
         "olympus": "https://eur-olympus.gameloft.com:443",
         "iris": "https://eur-iris.gameloft.com:443",
         "hermes": "https://eur-hermes.gameloft.com",
+        "anubisfinder": "https://eur-anubisfinder.gameloft.com:443",
         "pandora": "https://vgold-eur.gameloft.com",
-        "game_portal": "https://app-468561b3-9ecd-4d21-8241-30ed288f4d8b.gold0009.gameloft.com"
+        "game_portal": "https://app-468561b3-9ecd-4d21-8241-30ed288f4d8b.gold0009.gameloft.com",
+        "arion": "https://eur-arion.gameloft.com"
     }
     
     def __init__(
         self,
         username: Optional[str] = None,
         password: Optional[str] = None,
-        client_id: str = "1875:55979:6.0.0a:windows:windows",
+        platform: Platform = Platform.PC,
+        client_id: Optional[str] = None,
         auto_refresh: bool = True,
         timeout: int = 30,
         max_retries: int = 3
@@ -61,12 +72,25 @@ class MC5Client:
         Args:
             username: MC5 username
             password: MC5 password
-            client_id: Game client identifier
+            platform: Platform to use (PC or Android)
+            client_id: Game client identifier (auto-generated if not provided)
             auto_refresh: Automatically refresh expired tokens
             timeout: Request timeout in seconds
             max_retries: Maximum number of retry attempts
         """
-        self.client_id = client_id
+        # Set platform configuration
+        self.platform = platform
+        self.platform_config = get_platform_config(platform)
+        
+        # Use platform-specific client_id if not provided
+        if client_id is None:
+            self.client_id = self.platform_config.get_client_id()
+        else:
+            self.client_id = client_id
+            # Detect platform from custom client_id
+            self.platform = detect_platform_from_client_id(client_id)
+            self.platform_config = get_platform_config(self.platform)
+        
         self.auto_refresh = auto_refresh
         self.timeout = timeout
         self.max_retries = max_retries
@@ -92,7 +116,7 @@ class MC5Client:
         
         # Default headers
         self.session.headers.update({
-            "User-Agent": "MC5-API-Client/1.0.0",
+            "User-Agent": self.platform_config.get_user_agent(),
             "Accept": "*/*",
             "Content-Type": "application/x-www-form-urlencoded",
             "Connection": "close"
@@ -122,6 +146,10 @@ class MC5Client:
         self._username = username
         self._password = password
         
+        # Generate platform-specific device ID if not provided
+        if device_id is None:
+            device_id = self.platform_config.generate_device_id()
+        
         self._token_data = self.token_generator.generate_token(
             username=username,
             password=password,
@@ -173,7 +201,7 @@ class MC5Client:
         require_token: bool = True
     ) -> Dict[str, Any]:
         """
-        Make an HTTP request with proper error handling.
+        Make an HTTP request with proper error handling and telemetry.
         
         Args:
             method: HTTP method (GET, POST, PUT, DELETE)
@@ -191,6 +219,13 @@ class MC5Client:
             MC5APIError: For API-related errors
             NetworkError: For network-related errors
         """
+        import time
+        start_time = time.time()
+        function_name = f"{method.upper()} {url.split('/')[-1]}"
+        
+        # if is_telemetry_enabled():
+        #     print(f"🔍 Debug: Making {method} request to {url}")
+        
         if require_token:
             self._ensure_valid_token()
             # Add access token to params
@@ -214,29 +249,69 @@ class MC5Client:
                 timeout=self.timeout
             )
             
+            duration = time.time() - start_time
+            
             # Handle different response types
             if response.status_code == 200:
                 try:
-                    return response.json()
+                    result = response.json()
+                    # if is_telemetry_enabled():
+                    #     print(f"✅ Debug: {method} request successful ({duration:.2f}s)")
+                    report_usage(function_name, True, duration, {
+                        "status_code": response.status_code,
+                        "response_size": len(str(result))
+                    })
+                    return result
                 except json.JSONDecodeError:
-                    return {"response": response.text}
+                    result = {"response": response.text}
+                    # if is_telemetry_enabled():
+                    #     print(f"✅ Debug: {method} request successful (text response, {duration:.2f}s)")
+                    report_usage(function_name, True, duration, {
+                        "status_code": response.status_code,
+                        "response_type": "text"
+                    })
+                    return result
             
             elif response.status_code == 401:
-                raise AuthenticationError("Unauthorized - invalid or expired token")
+                error = AuthenticationError("Unauthorized - invalid or expired token")
+                # if is_telemetry_enabled():
+                #     print(f"❌ Debug: Authentication failed ({duration:.2f}s)")
+                report_error(error, f"{method} {url}", {
+                    "status_code": response.status_code,
+                    "duration": duration
+                })
+                raise error
             
             elif response.status_code == 403:
                 try:
                     error_data = response.json()
-                    raise InsufficientScopeError(error_data.get("error", "Insufficient permissions"))
+                    error = InsufficientScopeError(error_data.get("error", "Insufficient permissions"))
                 except:
-                    raise InsufficientScopeError("Insufficient permissions")
+                    error = InsufficientScopeError("Insufficient permissions")
+                
+                if is_telemetry_enabled():
+                    print(f"❌ Debug: Permission denied ({duration:.2f}s)")
+                report_error(error, f"{method} {url}", {
+                    "status_code": response.status_code,
+                    "duration": duration
+                })
+                raise error
             
             elif response.status_code == 429:
                 retry_after = response.headers.get("Retry-After")
-                raise RateLimitError(
+                error = RateLimitError(
                     "Rate limit exceeded",
                     retry_after=int(retry_after) if retry_after else None
                 )
+                
+                if is_telemetry_enabled():
+                    print(f"⏱️ Debug: Rate limit hit ({duration:.2f}s)")
+                report_error(error, f"{method} {url}", {
+                    "status_code": response.status_code,
+                    "retry_after": retry_after,
+                    "duration": duration
+                })
+                raise error
             
             else:
                 try:
@@ -245,18 +320,51 @@ class MC5Client:
                 except:
                     error_msg = response.text or "Unknown error"
                 
-                raise MC5APIError(
+                error = MC5APIError(
                     f"Request failed with status {response.status_code}: {error_msg}",
                     status_code=response.status_code,
                     response_data=error_data if 'error_data' in locals() else {}
                 )
-        
-        except requests.exceptions.Timeout:
-            raise NetworkError("Request timed out")
-        except requests.exceptions.ConnectionError:
-            raise NetworkError("Connection failed")
+                
+                if is_telemetry_enabled():
+                    print(f"❌ Debug: API error {response.status_code}: {error_msg} ({duration:.2f}s)")
+                report_error(error, f"{method} {url}", {
+                    "status_code": response.status_code,
+                    "error_message": error_msg,
+                    "duration": duration
+                })
+                raise error
+        
+        except requests.exceptions.Timeout as e:
+            error = NetworkError("Request timed out")
+            if is_telemetry_enabled():
+                print(f"⏰ Debug: Request timeout ({time.time() - start_time:.2f}s)")
+            report_error(error, f"{method} {url}", {
+                "error_type": "timeout",
+                "duration": time.time() - start_time
+            })
+            raise error
+            
+        except requests.exceptions.ConnectionError as e:
+            error = NetworkError("Connection failed")
+            if is_telemetry_enabled():
+                print(f"🔌 Debug: Connection failed ({time.time() - start_time:.2f}s)")
+            report_error(error, f"{method} {url}", {
+                "error_type": "connection",
+                "duration": time.time() - start_time
+            })
+            raise error
+            
         except requests.exceptions.RequestException as e:
-            raise NetworkError(f"Network error: {str(e)}")
+            error = NetworkError(f"Network error: {str(e)}")
+            if is_telemetry_enabled():
+                print(f"🌐 Debug: Network error ({time.time() - start_time:.2f}s): {e}")
+            report_error(error, f"{method} {url}", {
+                "error_type": "network",
+                "error_message": str(e),
+                "duration": time.time() - start_time
+            })
+            raise error
     
     # Profile Management
     
@@ -1007,6 +1115,126 @@ class MC5Client:
             return self.delete_multiple_inbox_messages(message_ids)
         return {"status": "success", "message": "No messages to delete"}
     
+    def remove_friend(self, target_user_id: str, message: str = "removed", 
+                     killsig_color: str = None, killsig_name: str = None) -> Dict[str, Any]:
+        """
+        Send a friend removal notification message.
+        
+        Args:
+            target_user_id: Target player's user ID
+            message: Message content (default: "removed")
+            killsig_color: Kill signature color (optional)
+            killsig_name: Kill signature name (optional)
+            
+        Returns:
+            Message result
+        """
+        url = f"{self.BASE_URLS['hermes']}/messages/inbox/{quote(target_user_id)}"
+        headers = {
+            'Content-Type': 'application/x-www-form-urlencoded'
+        }
+        
+        data = {
+            'access_token': self._token_data["access_token"],
+            'from': self.get_profile().get('credential', ''),
+            'body': message,
+            'reply_to': target_user_id,
+            '_type': 'friendRemoved',
+            'type': 'friendRemoved'
+        }
+        
+        # Add optional parameters
+        if killsig_color:
+            data['_killSignColor'] = killsig_color
+            data['killSignColor'] = killsig_color
+        if killsig_name:
+            data['_killSignName'] = killsig_name
+            data['killSignName'] = killsig_name
+        
+        response = self._make_request("POST", url, data=data)
+        return response
+    
+    def delete_friend_connection(self, target_user_id: str) -> Dict[str, Any]:
+        """
+        Delete a friend connection (actual removal from friends list).
+        
+        Args:
+            target_user_id: Target player's user ID
+            
+        Returns:
+            Deletion result
+        """
+        url = f"{self.BASE_URLS['osiris']}/accounts/me/connections/friend/{quote(target_user_id)}/delete"
+        headers = {
+            'Content-Type': 'application/x-www-form-urlencoded'
+        }
+        
+        data = {
+            'access_token': self._token_data["access_token"],
+            'target_credential': target_user_id
+        }
+        
+        response = self._make_request("POST", url, data=data)
+        return response
+    
+    def send_friend_request(self, target_user_id: str, alert_kairos: bool = True) -> Dict[str, Any]:
+        """
+        Send a friend request to another player.
+        
+        Args:
+            target_user_id: Target player's user ID
+            alert_kairos: Whether to send alert notification
+            
+        Returns:
+            Friend request result
+        """
+        url = f"{self.BASE_URLS['osiris']}/accounts/me/connections/friend"
+        headers = {
+            'Content-Type': 'application/x-www-form-urlencoded'
+        }
+        
+        data = {
+            'access_token': self._token_data["access_token"],
+            'target_credential': target_user_id,
+            'requester_credential': self.get_profile().get('credential', ''),
+            'alert_kairos': str(alert_kairos).lower()
+        }
+        
+        response = self._make_request("POST", url, data=data)
+        return response
+    
+    def get_friend_connection_status(self, target_user_id: str) -> Dict[str, Any]:
+        """
+        Get the connection status with a specific friend.
+        
+        Args:
+            target_user_id: Target player's user ID
+            
+        Returns:
+            Connection status information
+        """
+        url = f"{self.BASE_URLS['osiris']}/accounts/me/connections/friend/{quote(target_user_id)}"
+        params = {
+            'access_token': self._token_data["access_token"],
+            'target_credential': target_user_id
+        }
+        
+        response = self._make_request("GET", url, params=params)
+        return response
+    
+    def accept_friend_request(self, request_id: str) -> Dict[str, Any]:
+        """
+        Accept an incoming friend request.
+        
+        Args:
+            request_id: Friend request ID to accept
+            
+        Returns:
+            Accept result with connection details
+        """
+        url = f"{self.BASE_URLS['osiris']}/accounts/me/requests/{request_id}/accept"
+        return self._make_request("POST", url)
+    
     def send_squad_wall_message(self, clan_id: str, message: str, msg_type: int = 0, 
                                player_killsig: str = None, player_killsig_color: str = None,
                                language: str = "en", activity_type: str = "user_post") -> Dict[str, Any]:
@@ -1066,20 +1294,6 @@ class MC5Client:
         response = self._make_request("GET", url)
         return response.get("friends", [])
     
-    def send_friend_request(self, credential: str) -> Dict[str, Any]:
-        """
-        Send friend request.
-        
-        Args:
-            credential: Target player credential
-            
-        Returns:
-            Friend request result
-        """
-        url = f"{self.BASE_URLS['osiris']}/accounts/me/friends"
-        data = {"credential": credential}
-        return self._make_request("POST", url, data=data)
-    
     def check_friend_status(self, credential: str) -> Dict[str, Any]:
         """
         Check friend connection status.
@@ -1139,6 +1353,136 @@ class MC5Client:
                 return event
         raise MC5APIError(f"Event '{event_name}' not found")
     
+    def sign_up_for_event(self, event_id: str) -> Dict[str, Any]:
+        """
+        Sign up for an event.
+        
+        Args:
+            event_id: Event ID to sign up for
+            
+        Returns:
+            Signup result
+        """
+        url = f"{self.BASE_URLS['osiris']}/events/{event_id}/participants/me"
+        return self._make_request("POST", url)
+    
+    def get_event_leaderboard(self, event_id: str, offset: int = 0, limit: int = 100) -> Dict[str, Any]:
+        """
+        Get the leaderboard for a specific event.
+        
+        Args:
+            event_id: Event ID
+            offset: Pagination offset (default: 0)
+            limit: Number of entries to retrieve (default: 100)
+            
+        Returns:
+            Event leaderboard data
+        """
+        url = f"{self.BASE_URLS['olympus']}/leaderboards/desc/Leaderboard_{event_id}"
+        params = {
+            "offset": str(offset),
+            "limit": str(limit)
+        }
+        return self._make_request("GET", url, params=params)
+    
+    def get_my_event_leaderboard_entry(self, event_id: str, limit: int = 5) -> Dict[str, Any]:
+        """
+        Get your entry and surrounding players in the event leaderboard.
+        
+        Args:
+            event_id: Event ID
+            limit: Number of surrounding entries to show (default: 5)
+            
+        Returns:
+            Your leaderboard entry with surrounding players
+        """
+        url = f"{self.BASE_URLS['olympus']}/leaderboards/desc/Leaderboard_{event_id}/me"
+        params = {
+            "limit": str(limit)
+        }
+        return self._make_request("GET", url, params=params)
+    
+    # Squad/Group Management
+    
+    def get_squad_invitations(self) -> List[Dict[str, Any]]:
+        """
+        Get all pending squad invitations.
+        
+        Returns:
+            List of squad invitations
+        """
+        url = f"{self.BASE_URLS['osiris']}/accounts/me/requests"
+        params = {
+            "request_type": "group_invitation"
+        }
+        response = self._make_request("GET", url, params=params)
+        return response if isinstance(response, list) else []
+    
+    def accept_squad_invitation(self, group_id: str, credential: str, 
+                              killsig_color: str = None, killsig_id: str = None,
+                              score: str = None, xp: str = None) -> Dict[str, Any]:
+        """
+        Accept a squad invitation and join the squad.
+        
+        Args:
+            group_id: Squad/group ID
+            credential: Your credential (user ID)
+            killsig_color: Kill signature color (optional)
+            killsig_id: Kill signature ID (optional)
+            score: Your score (optional)
+            xp: Your XP (optional)
+            
+        Returns:
+            Accept result
+        """
+        url = f"{self.BASE_URLS['osiris']}/groups/{group_id}/members/{quote(credential)}"
+        data = {
+            "credential": credential,
+            "operation": "update"
+        }
+        
+        # Add optional parameters
+        if killsig_color is not None:
+            data["_killsig_color"] = str(killsig_color)
+        if killsig_id is not None:
+            data["_killsig_id"] = killsig_id
+        if score is not None:
+            data["_score"] = str(score)
+        if xp is not None:
+            data["_xp"] = str(xp)
+        
+        return self._make_request("POST", url, data=data)
+    
+    def delete_squad_invitation_message(self, message_id: str) -> Dict[str, Any]:
+        """
+        Delete a squad invitation message after accepting/declining.
+        
+        Args:
+            message_id: Message ID to delete
+            
+        Returns:
+            Delete result
+        """
+        url = f"{self.BASE_URLS['hermes']}/messages/inbox/me"
+        params = {
+            "msgids": message_id
+        }
+        return self._make_request("DELETE", url, params=params)
+    
+    def decline_squad_invitation(self, message_id: str) -> Dict[str, Any]:
+        """
+        Decline a squad invitation by rejecting the request.
+        
+        Args:
+            message_id: Message ID to decline/reject
+            
+        Returns:
+            Decline result
+        """
+        # Use the correct endpoint to actually reject the invitation
+        url = f"{self.BASE_URLS['osiris']}/accounts/me/requests/{message_id}/reject"
+        return self._make_request("POST", url)
+    
     # Leaderboard
     
     def get_leaderboard(self, leaderboard_type: str = "ro") -> Dict[str, Any]:
@@ -2267,6 +2611,503 @@ class MC5Client:
         
         return parsed_stats
     
+    def get_platform_info(self) -> Dict[str, Any]:
+        """
+        Get current platform information.
+        
+        Returns:
+            Platform configuration details
+        """
+        return {
+            "platform": self.platform.value,
+            "client_id": self.client_id,
+            "device_info": self.platform_config.get_device_info(),
+            "user_agent": self.platform_config.get_user_agent(),
+            "platform_id": self.platform_config.get_platform_id()
+        }
+    
+    def switch_platform(self, platform: Platform) -> None:
+        """
+        Switch to a different platform.
+        
+        Args:
+            platform: New platform to use
+        """
+        self.platform = platform
+        self.platform_config = get_platform_config(platform)
+        self.client_id = self.platform_config.get_client_id()
+        
+        # Update session headers
+        self.session.headers.update({
+            "User-Agent": self.platform_config.get_user_agent()
+        })
+        
+        # Reinitialize token generator with new client_id
+        self.token_generator = TokenGenerator(
+            client_id=self.client_id,
+            timeout=self.timeout,
+            max_retries=self.max_retries
+        )
+        
+        # Clear existing token
+        self._token_data = None
+    
+    def generate_platform_credential(self) -> str:
+        """
+        Generate platform-specific anonymous credential.
+        
+        Returns:
+            Platform-appropriate anonymous credential
+        """
+        if self.platform == Platform.ANDROID:
+            return self.platform_config.generate_android_credential()
+        else:
+            # PC credential format
+            import random
+            import string
+            return f"win8_v2_{random.randint(100000000, 999999999)}_{''.join(random.choices(string.ascii_letters + string.digits, k=20))}"
+    
+    def subscribe_to_chat_room(self, room_id: str, language: str = "en") -> Dict[str, Any]:
+        """
+        Subscribe to a chat room (Android-specific).
+        
+        Args:
+            room_id: Chat room ID
+            language: Language code
+            
+        Returns:
+            Chat subscription information
+        """
+        self._ensure_valid_token()
+        
+        url = f"{self.BASE_URLS['arion']}/chat/rooms/{room_id}/subscribe"
+        data = {
+            "language": language,
+            "access_token": self._token_data['access_token']
+        }
+        
+        return self._make_request("POST", url, data=data)
+    
+    def send_squad_message(
+        self, 
+        room_id: str, 
+        message: str, 
+        kill_sign: str = "default_killsig_03",
+        kill_sign_color: str = "1212155"
+    ) -> Dict[str, Any]:
+        """
+        Send message to squad chat room (Android-specific).
+        
+        Args:
+            room_id: Squad room ID
+            message: Message content
+            kill_sign: Kill signature
+            kill_sign_color: Kill signature color
+            
+        Returns:
+            Message response
+        """
+        self._ensure_valid_token()
+        
+        # Get chat URL from subscription
+        subscription = self.subscribe_to_chat_room(room_id)
+        chat_url = subscription.get('cmd_url')
+        
+        if not chat_url:
+            raise MC5APIError("Could not get chat URL from subscription")
+        
+        data = {
+            "_killSignColor": kill_sign_color,
+            "_fedId": f"fed_id:{self._token_data.get('fed_id', '')}",
+            "_senderTimestamp": str(int(time.time())),
+            "_senderName": self._username.split(":")[-1] if ":" in self._username else "Player",
+            "_anonId": self._username,
+            "_killSign": kill_sign,
+            "_": "wU\\UWZ",  # Android signature
+            "msg": message,
+            "user": '{"nickname":"' + (self._username.split(":")[-1] if ":" in self._username else "Player") + '"}',
+            "access_token": self._token_data['access_token']
+        }
+        
+        return self._make_request("POST", chat_url, data=data)
+    
+    def send_global_message(
+        self, 
+        message: str, 
+        nickname: str = "Player",
+        kill_sign: str = "default_killsig_03"
+    ) -> Dict[str, Any]:
+        """
+        Send message to global chat (Android-specific).
+        
+        Args:
+            message: Message content
+            nickname: Player nickname
+            kill_sign: Kill signature
+            
+        Returns:
+            Message response
+        """
+        self._ensure_valid_token()
+        
+        # Global chat endpoint
+        url = "https://eur-fedex-fsg006.gameloft.com:54435/v1/chat/channels/mc5_global.en"
+        
+        data = {
+            "_killSignColor": "1212155",
+            "_fedId": f"fed_id:{self._token_data.get('fed_id', '')}",
+            "_senderTimestamp": str(int(time.time())),
+            "_senderName": nickname,
+            "_anonId": self._username,
+            "_killSign": kill_sign,
+            "_": "wU\\UWZ",
+            "msg": message,
+            "user": '{"nickname":"' + nickname + '"}',
+            "access_token": self._token_data['access_token']
+        }
+        
+        return self._make_request("POST", url, data=data)
+    
+    def get_squad_wall(
+        self, 
+        room_id: str, 
+        limit: int = 20,
+        include_fields: List[str] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        Get squad wall posts (Android-specific).
+        
+        Args:
+            room_id: Squad room ID
+            limit: Number of posts to retrieve
+            include_fields: Fields to include in response
+            
+        Returns:
+            List of wall posts
+        """
+        self._ensure_valid_token()
+        
+        if include_fields is None:
+            include_fields = ["actor", "creation", "id", "text"]
+        
+        url = f"{self.BASE_URLS['osiris']}/groups/{room_id}/wall"
+        params = {
+            "access_token": self._token_data['access_token'],
+            "sort_type": "chronological",
+            "limit": str(limit),
+            "include_fields": ",".join(include_fields)
+        }
+        
+        return self._make_request("GET", url, params=params)
+    
+    def send_private_message(
+        self,
+        target_credential: str,
+        message: str,
+        from_name: str = "Player",
+        kill_sign: str = "default_killsig_03",
+        kill_sign_color: str = "1212155"
+    ) -> Dict[str, Any]:
+        """
+        Send private message (Android-specific).
+        
+        Args:
+            target_credential: Target user's credential
+            message: Message content
+            from_name: Sender name
+            kill_sign: Kill signature
+            kill_sign_color: Kill signature color
+            
+        Returns:
+            Message response
+        """
+        self._ensure_valid_token()
+        
+        url = f"{self.BASE_URLS['hermes']}/messages/inbox/{target_credential}"
+        data = {
+            "access_token": self._token_data['access_token'],
+            "alert_kairos": "true",
+            "from": from_name,
+            "body": message,
+            "reply_to": self._username,
+            "_killSignColor": kill_sign_color,
+            "_killSignName": kill_sign,
+            "_type": "inbox"
+        }
+        
+        return self._make_request("POST", url, data=data)
+    
+    def check_friend_connection(self, target_credential: str) -> Dict[str, Any]:
+        """
+        Check friend connection status (Android-specific).
+        
+        Args:
+            target_credential: Target user's credential
+            
+        Returns:
+            Friend connection status
+        """
+        self._ensure_valid_token()
+        
+        url = f"{self.BASE_URLS['osiris']}/accounts/me/connections/friend/{target_credential}"
+        params = {
+            "access_token": self._token_data['access_token'],
+            "target_credential": target_credential
+        }
+        
+        return self._make_request("GET", url, params=params)
+    
+    def remove_friend(
+        self,
+        target_credential: str
+    ) -> Dict[str, Any]:
+        """
+        Remove friend connection (Android-specific).
+        
+        Args:
+            target_credential: Target user's credential to remove
+            
+        Returns:
+            Friend removal response
+        """
+        self._ensure_valid_token()
+        
+        url = f"{self.BASE_URLS['osiris']}/accounts/me/connections/friend/{target_credential}/delete"
+        data = {
+            "access_token": self._token_data['access_token'],
+            "target_credential": target_credential
+        }
+        
+        return self._make_request("POST", url, data=data)
+    
+    def send_friend_removed_message(
+        self,
+        target_credential: str,
+        message: str = "removed",
+        from_name: str = "Player",
+        kill_sign: str = "default_killsig_03",
+        kill_sign_color: str = "1212155"
+    ) -> Dict[str, Any]:
+        """
+        Send friend removed notification message (Android-specific).
+        
+        Args:
+            target_credential: Target user's credential
+            message: Message content (default: "removed")
+            from_name: Sender name
+            kill_sign: Kill signature
+            kill_sign_color: Kill signature color
+            
+        Returns:
+            Message response
+        """
+        self._ensure_valid_token()
+        
+        url = f"{self.BASE_URLS['hermes']}/messages/inbox/{target_credential}"
+        data = {
+            "access_token": self._token_data['access_token'],
+            "alert_kairos": "true",
+            "from": from_name,
+            "body": message,
+            "reply_to": self._username,
+            "_killSignColor": kill_sign_color,
+            "_killSignName": kill_sign,
+            "_type": "friendRemoved"
+        }
+        
+        return self._make_request("POST", url, data=data)
+    
+    def update_squad_info(
+        self,
+        clan_id: str,
+        rating: Optional[int] = None,
+        score: Optional[int] = None,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        member_count: Optional[int] = None,
+        member_limit: Optional[int] = None,
+        membership: Optional[str] = None,
+        logo: Optional[str] = None,
+        logo_color_primary: Optional[int] = None,
+        logo_color_secondary: Optional[int] = None,
+        min_join_value: Optional[int] = None,
+        currency: Optional[int] = None,
+        active_clan_label: Optional[bool] = None
+    ) -> Dict[str, Any]:
+        """
+        Update squad information (Android-specific).
+        
+        Args:
+            clan_id: Squad/Clan ID to update
+            rating: Squad rating value
+            score: Squad score (may not update in-game)
+            name: Squad name
+            description: Squad description
+            member_count: Current member count
+            member_limit: Maximum member limit
+            membership: Membership type (e.g., "owner_approved")
+            logo: Logo ID
+            logo_color_primary: Primary logo color
+            logo_color_secondary: Secondary logo color
+            min_join_value: Minimum join value
+            currency: Squad currency
+            active_clan_label: Whether clan label is active
+            
+        Returns:
+            Update response
+        """
+        self._ensure_valid_token()
+        
+        url = f"{self.BASE_URLS['osiris']}/groups/{clan_id}"
+        
+        # Build payload with provided parameters
+        payload = {
+            "access_token": self._token_data['access_token'],
+            "timestamp": str(int(time.time())),
+            "_anonId": self._username
+        }
+        
+        # Add optional parameters if provided
+        if rating is not None:
+            payload["_rating"] = str(rating)
+        if score is not None:
+            payload["score"] = str(score)
+        if name is not None:
+            payload["name"] = name
+        if description is not None:
+            payload["description"] = description
+        if member_count is not None:
+            payload["member_count"] = str(member_count)
+        if member_limit is not None:
+            payload["member_limit"] = str(member_limit)
+        if membership is not None:
+            payload["membership"] = membership
+        if logo is not None:
+            payload["_logo"] = logo
+        if logo_color_primary is not None:
+            payload["_logo_clr_prim"] = str(logo_color_primary)
+        if logo_color_secondary is not None:
+            payload["_logo_clr_sec"] = str(logo_color_secondary)
+        if min_join_value is not None:
+            payload["_min_join_value"] = str(min_join_value)
+        if currency is not None:
+            payload["currency"] = str(currency)
+        if active_clan_label is not None:
+            payload["active_clan_label"] = "true" if active_clan_label else "false"
+        
+        return self._make_request("POST", url, data=payload)
+    
+    def get_squad_info(
+        self,
+        clan_id: str
+    ) -> Dict[str, Any]:
+        """
+        Get squad information (Android-specific).
+        
+        Args:
+            clan_id: Squad/Clan ID to retrieve
+            
+        Returns:
+            Squad information
+        """
+        self._ensure_valid_token()
+        
+        url = f"{self.BASE_URLS['osiris']}/groups/{clan_id}"
+        params = {
+            "access_token": self._token_data['access_token']
+        }
+        
+        return self._make_request("GET", url, params=params)
+    
+    def post_to_squad_wall(
+        self,
+        room_id: str,
+        message: str,
+        kill_sign: str = "default_killsig_03",
+        kill_sign_color: int = 1212155,
+        language: str = "en"
+    ) -> Dict[str, Any]:
+        """
+        Post to squad wall (Android-specific).
+        
+        Args:
+            room_id: Squad room ID
+            message: Message content
+            kill_sign: Kill signature
+            kill_sign_color: Kill signature color
+            language: Language code
+            
+        Returns:
+            Wall post response
+        """
+        self._ensure_valid_token()
+        
+        url = f"{self.BASE_URLS['osiris']}/groups/{room_id}/wall"
+        
+        post_data = {
+            "msg_body": message,
+            "msg_type": 0,
+            "playerKillSign": kill_sign,
+            "playerKillSignColor": kill_sign_color
+        }
+        
+        data = {
+            "access_token": self._token_data['access_token'],
+            "text": json.dumps(post_data) + "\n",
+            "language": language,
+            "activity_type": "user_post",
+            "alert_kairos": "false"
+        }
+        
+        return self._make_request("POST", url, data=data)
+    
+    def get_game_alias(self) -> Dict[str, Any]:
+        """
+        Get game alias (Android-specific).
+        
+        Returns:
+            Game alias information
+        """
+        self._ensure_valid_token()
+        
+        url = f"{self.BASE_URLS['janus']}/games/mygame/alias"
+        data = {
+            "access_token": self._token_data['access_token']
+        }
+        
+        return self._make_request("POST", url, data=data)
+    
+    def get_batch_profiles(
+        self,
+        credentials: List[str],
+        include_fields: List[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Get batch profiles for multiple credentials (Android-specific).
+        
+        Args:
+            credentials: List of player credentials (fed_id:... format)
+            include_fields: Fields to include in response
+            
+        Returns:
+            Batch profile data
+        """
+        if include_fields is None:
+            include_fields = ["_game_save", "inventory"]
+        
+        # Use game portal endpoint
+        url = f"{self.BASE_URLS['game_portal']}/1924/190/public/OfficialScripts/mc5Portal.wsgi"
+        
+        data = {
+            "op_code": "get_batch_profiles",
+            "client_id": self.client_id,
+            "credentials": ",".join(credentials),
+            "pandora": f"https://vgold-eur.gameloft.com/{self.client_id}",
+            "include_fields": ",".join(include_fields)
+        }
+        
+        return self._make_request("POST", url, data=data)
+    
     def __enter__(self):
         """Context manager entry."""
         return self