Android SDK - Complete Integration Guide

dependencies {
    implementation 'ai.gettranslated:android-sdk:1.0.0'
    // ... other dependencies
}

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

public class MyApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        // Initialize GetTranslated SDK
        // This should be done in Application.onCreate() before activities are created
        GetTranslated.init(getApplicationContext(), "your-ck-api-key");
    }
}

public class MyApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        // Initialize with callback to handle initialization status
        // This should be done in Application.onCreate() before activities are created
        GetTranslated.init(getApplicationContext(), "your-ck-api-key", new GetTranslated.InitCallback() {
            @Override
            public void onInitSuccess() {
                Log.d("GetTranslated", "SDK initialized successfully");
                // SDK is ready to use
            }
            
            @Override
            public void onInitError(int errorCode, String errorMessage) {
                Log.e("GetTranslated", "Initialization failed: " + errorMessage);
                // Handle initialization error
                // errorCode: HTTP status code (401, 403, 500) or 0 for network/parsing errors
            }
        });
    }
}

public class MainActivity extends AppCompatActivity {
    private boolean sdkInitialized = false;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        // Apply saved language preference before inflating views
        applySavedLanguagePreference();
        
        // Initialize SDK early (before views) so language can be applied
        initializeSDK();
        
        setContentView(R.layout.activity_main);
        
        initializeViews();
        setupClickListeners();
        
        // Check SDK initialization status and update UI
        updateInitializationStatus();
    }
    
    private void applySavedLanguagePreference() {
        try {
            SharedPreferences prefs = getSharedPreferences(
                ai.gettranslated.sdk.Constants.PREF_KEY, Context.MODE_PRIVATE);
            String storedUserId = ai.gettranslated.sdk.StorageKeys.getStoredUserId(prefs);
            
            if (storedUserId != null) {
                String savedLang = ai.gettranslated.sdk.StorageKeys.getUserLanguageOverride(prefs, storedUserId);
                if (savedLang != null && !savedLang.isEmpty()) {
                    Locale locale = Locale.forLanguageTag(savedLang);
                    Locale.setDefault(locale);
                    Configuration config = getResources().getConfiguration();
                    config.setLocale(locale);
                    getResources().updateConfiguration(config, getResources().getDisplayMetrics());
                }
            }
        } catch (Exception e) {
            Log.e("MainActivity", "Failed to apply saved language", e);
        }
    }
    
    private void initializeSDK() {
        GetTranslated.init(getApplicationContext(), "your-ck-api-key", new GetTranslated.InitCallback() {
            @Override
            public void onInitSuccess() {
                runOnUiThread(() -> {
                    sdkInitialized = true;
                    updateUI();
                });
            }
            
            @Override
            public void onInitError(int errorCode, String errorMessage) {
                runOnUiThread(() -> {
                    sdkInitialized = false;
                    updateUI();
                });
            }
        });
    }
    
    private void updateInitializationStatus() {
        // Query SDK status after views are created
        boolean isInitialized = GetTranslated.isInitialized();
        sdkInitialized = isInitialized;
        
        if (isInitialized) {
            // Update UI to show SDK is ready
            Set<String> languages = GetTranslated.getLanguages();
            // ... update UI elements
        }
    }
}

// Synchronous translation
String translated = GetTranslated.getDynamicString("Hello, World!");

// Asynchronous translation with callback
GetTranslated.getDynamicString("Hello, World!", new GetTranslated.TranslationCallback() {
    @Override
    public void onTranslationReady(String translation) {
        // Update UI on main thread
        runOnUiThread(() -> {
            textView.setText(translation);
        });
    }
    
    @Override
    public void onTranslationError(String errorMessage) {
        // Handle error
        Log.e("Translation", "Error: " + errorMessage);
    }
});

// Get supported languages
Set<String> languages = GetTranslated.getLanguages();

// Get current language (automatically set by SDK)
String currentLang = GetTranslated.getCurrentLanguage();

// Optional: Manually set language (only if implementing a language selector)
GetTranslated.setLanguage("es");

public interface InitCallback {
    /**
     * Called when SDK initialization succeeds.
     */
    void onInitSuccess();

    /**
     * Called if there is an error during SDK initialization.
     *
     * @param errorCode The HTTP error code (e.g., 401, 403, 500), or 0 for network/parsing errors
     * @param errorMessage A description of the error
     */
    void onInitError(int errorCode, String errorMessage);
}

public interface TranslationCallback {
    /**
     * Called when the requested translation is available.
     *
     * @param translation The requested translation
     */
    void onTranslationReady(String translation);

    /**
     * Called if there is an error completing the translation request.
     *
     * @param errorMessage A description of the error
     */
    void onTranslationError(String errorMessage);
}

// Log Levels
public enum LogLevel {
    ERROR(0),    // Only error messages
    WARN(1),     // Warning and error messages (default)
    INFO(2),     // Informational, warning, and error messages
    DEBUG(3),    // Debug, info, warning, and error messages
    VERBOSE(4);  // All messages
}

// Initialize logger
Logger.init(Logger.LogLevel.DEBUG, true, false);

// Log messages
Logger.logInfo("Your message");
Logger.logError("Error occurred", exception);
Logger.logDebug("Debug information", data);
Logger.logWarn("Warning message");
Logger.logVerbose("Verbose information");

// Initialize with custom logging
Logger.init(Logger.LogLevel.VERBOSE, true, false);

// Or configure after initialization
Logger logger = Logger.getInstance();
logger.setLevel(Logger.LogLevel.DEBUG);

public String getTranslationSafely(String text) {
    try {
        return GetTranslated.getDynamicString(text);
    } catch (Exception e) {
        Logger.logError("Translation failed", e);
        return text; // Return original text as fallback
    }
}

public void translateWithRetry(String text, int maxRetries) {
    GetTranslated.getDynamicString(text, new GetTranslated.TranslationCallback() {
        @Override
        public void onTranslationReady(String translation) {
            // Success - update UI
            updateUI(translation);
        }
        
        @Override
        public void onTranslationError(String errorMessage) {
            if (maxRetries > 0) {
                // Retry with exponential backoff
                new Handler().postDelayed(() -> {
                    translateWithRetry(text, maxRetries - 1);
                }, 1000 * (4 - maxRetries)); // 1s, 2s, 3s delays
            } else {
                // Final failure - show fallback
                updateUI(text);
            }
        }
    });
}

public class UserManager {
    private static final String PREFS_NAME = "user_prefs";
    private static final String USER_ID_KEY = "user_id";
    
    public void loginUser(String userId) {
        // Use callback to handle re-initialization after login
        GetTranslated.login(userId, new GetTranslated.InitCallback() {
            @Override
            public void onInitSuccess() {
                // Login and re-initialization successful
                // Supported languages are preserved during re-initialization
                saveUserId(userId);
                notifyLoginSuccess();
            }
            
            @Override
            public void onInitError(int errorCode, String errorMessage) {
                Logger.logError("Login re-initialization failed: " + errorMessage, null);
                notifyLoginError(errorMessage);
            }
        });
    }
    
    public void logoutUser() {
        // Use callback to handle re-initialization after logout
        GetTranslated.logout(new GetTranslated.InitCallback() {
            @Override
            public void onInitSuccess() {
                // Logout and re-initialization successful
                // Supported languages are preserved during re-initialization
                clearUserId();
                notifyLogoutSuccess();
            }
            
            @Override
            public void onInitError(int errorCode, String errorMessage) {
                Logger.logError("Logout re-initialization failed: " + errorMessage, null);
            }
        });
    }
}

public class TranslationLoader {
    private final List<String> pendingTranslations = new ArrayList<>();
    private final Handler handler = new Handler(Looper.getMainLooper());
    private Runnable batchRunnable;
    
    public void loadTranslation(String text) {
        pendingTranslations.add(text);
        
        // Cancel previous batch if exists
        if (batchRunnable != null) {
            handler.removeCallbacks(batchRunnable);
        }
        
        // Schedule batch processing
        batchRunnable = this::processBatch;
        handler.postDelayed(batchRunnable, 100); // 100ms delay
    }
    
    private void processBatch() {
        List<String> batch = new ArrayList<>(pendingTranslations);
        pendingTranslations.clear();
        
        for (String text : batch) {
            GetTranslated.getDynamicString(text, new GetTranslated.TranslationCallback() {
                @Override
                public void onTranslationReady(String translation) {
                    notifyTranslationReady(text, translation);
                }
                
                @Override
                public void onTranslationError(String errorMessage) {
                    notifyTranslationError(text, errorMessage);
                }
            });
        }
    }
}

// Old way with string resources
String text = getString(R.string.hello_world);

// New way with dynamic translation
String text = GetTranslated.getDynamicString("Hello, World!");

Translate translate = TranslateOptions.getDefaultInstance().getService();
Translation translation = translate.translate("Hello", Translate.TranslateOption.targetLanguage("es"));
String result = translation.getTranslatedText();

GetTranslated.getDynamicString("Hello", new GetTranslated.TranslationCallback() {
    @Override
    public void onTranslationReady(String translation) {
        // Use translation
    }
    
    @Override
    public void onTranslationError(String errorMessage) {
        // Handle error
    }
});

public class MyApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        try {
            // Initialize in Application.onCreate() to ensure saved language
            // preferences are applied before any activities are created
            GetTranslated.init(getApplicationContext(), "your-ck-api-key", 
                new GetTranslated.InitCallback() {
                    @Override
                    public void onInitSuccess() {
                        Log.d("App", "SDK initialized successfully");
                    }
                    
                    @Override
                    public void onInitError(int errorCode, String errorMessage) {
                        Log.e("App", "SDK initialization failed: " + errorMessage);
                    }
                });
        } catch (Exception e) {
            Logger.logError("SDK initialization failed", e);
        }
    }
}

public void updateText(String originalText) {
    GetTranslated.getDynamicString(originalText, new GetTranslated.TranslationCallback() {
        @Override
        public void onTranslationReady(String translation) {
            runOnUiThread(() -> {
                textView.setText(translation);
            });
        }
        
        @Override
        public void onTranslationError(String errorMessage) {
            runOnUiThread(() -> {
                textView.setText(originalText); // Fallback
            });
        }
    });
}

// Example: Implementing a custom language selector (optional)
public void setLanguageSafely(String languageCode) {
    Set<String> supportedLanguages = GetTranslated.getLanguages();
    if (supportedLanguages.contains(languageCode)) {
        GetTranslated.setLanguage(languageCode);
        saveLanguagePreference(languageCode);
    } else {
        Logger.logWarn("Language not supported: " + languageCode);
    }
}

// Enable debug logging
GetTranslated.init(getApplicationContext(), "your-ck-api-key", null, Logger.LogLevel.DEBUG);

// Or configure logging separately
Logger.init(Logger.LogLevel.VERBOSE, true, false);

public class MainActivity extends AppCompatActivity {
    private static final String API_KEY = "your-ck-api-key";
    private static final String TAG = "MainActivity";
    
    private TextView welcomeText;
    private TextView descriptionText;
    private Button languageButton;
    private Button translateButton;
    private EditText customTextInput;
    private TextView customTranslationText;
    
    private String[] sampleTexts = {
        "Welcome to our app!",
        "This is a sample translation app.",
        "Tap the buttons to test translations."
    };
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        initializeViews();
        setupClickListeners();
        initializeSDK();
    }
    
    private void initializeViews() {
        welcomeText = findViewById(R.id.welcomeText);
        descriptionText = findViewById(R.id.descriptionText);
        languageButton = findViewById(R.id.languageButton);
        translateButton = findViewById(R.id.translateButton);
        customTextInput = findViewById(R.id.customTextInput);
        customTranslationText = findViewById(R.id.customTranslationText);
    }
    
    private void setupClickListeners() {
        languageButton.setOnClickListener(v -> switchLanguage());
        translateButton.setOnClickListener(v -> translateCustomText());
    }
    
    private void initializeSDK() {
        try {
            GetTranslated.init(getApplicationContext(), API_KEY, null, Logger.LogLevel.DEBUG);
            loadTranslations();
        } catch (Exception e) {
            Logger.logError("SDK initialization failed", e);
            showError("Failed to initialize translation service");
        }
    }
    
    private void loadTranslations() {
        // Load sample texts
        for (int i = 0; i < sampleTexts.length; i++) {
            final int index = i;
            GetTranslated.getDynamicString(sampleTexts[i], new GetTranslated.TranslationCallback() {
                @Override
                public void onTranslationReady(String translation) {
                    runOnUiThread(() -> updateSampleText(index, translation));
                }
                
                @Override
                public void onTranslationError(String errorMessage) {
                    Logger.logError("Translation failed for: " + sampleTexts[index], errorMessage);
                }
            });
        }
    }
    
    private void updateSampleText(int index, String translation) {
        switch (index) {
            case 0:
                welcomeText.setText(translation);
                break;
            case 1:
                descriptionText.setText(translation);
                break;
        }
    }
    
    private void switchLanguage() {
        String currentLang = GetTranslated.getCurrentLanguage();
        String newLang = "en".equals(currentLang) ? "es" : "en";
        
        try {
            GetTranslated.setLanguage(newLang);
            loadTranslations(); // Re-translate all texts
            updateLanguageButton();
        } catch (Exception e) {
            Logger.logError("Language switch failed", e);
            showError("Failed to switch language");
        }
    }
    
    private void updateLanguageButton() {
        String currentLang = GetTranslated.getCurrentLanguage();
        String buttonText = "en".equals(currentLang) ? "Switch to Spanish" : "Switch to English";
        languageButton.setText(buttonText);
    }
    
    private void translateCustomText() {
        String text = customTextInput.getText().toString().trim();
        if (text.isEmpty()) {
            showError("Please enter text to translate");
            return;
        }
        
        customTranslationText.setText("Translating...");
        
        GetTranslated.getDynamicString(text, new GetTranslated.TranslationCallback() {
            @Override
            public void onTranslationReady(String translation) {
                runOnUiThread(() -> {
                    customTranslationText.setText(translation);
                });
            }
            
            @Override
            public void onTranslationError(String errorMessage) {
                runOnUiThread(() -> {
                    customTranslationText.setText("Translation failed: " + errorMessage);
                });
            }
        });
    }
    
    private void showError(String message) {
        Toast.makeText(this, message, Toast.LENGTH_SHORT).show();
    }
}

public class TranslationService {
    private static TranslationService instance;
    private final Map<String, String> cache = new HashMap<>();
    private final List<TranslationListener> listeners = new ArrayList<>();
    
    public interface TranslationListener {
        void onTranslationReady(String original, String translation);
        void onTranslationError(String original, String error);
    }
    
    public static TranslationService getInstance() {
        if (instance == null) {
            instance = new TranslationService();
        }
        return instance;
    }
    
    public void addListener(TranslationListener listener) {
        listeners.add(listener);
    }
    
    public void removeListener(TranslationListener listener) {
        listeners.remove(listener);
    }
    
    public void translate(String text) {
        if (cache.containsKey(text)) {
            notifyTranslationReady(text, cache.get(text));
            return;
        }
        
        GetTranslated.getDynamicString(text, new GetTranslated.TranslationCallback() {
            @Override
            public void onTranslationReady(String translation) {
                cache.put(text, translation);
                notifyTranslationReady(text, translation);
            }
            
            @Override
            public void onTranslationError(String errorMessage) {
                notifyTranslationError(text, errorMessage);
            }
        });
    }
    
    public void translateBatch(List<String> texts) {
        for (String text : texts) {
            translate(text);
        }
    }
    
    public void clearCache() {
        cache.clear();
    }
    
    private void notifyTranslationReady(String original, String translation) {
        for (TranslationListener listener : listeners) {
            listener.onTranslationReady(original, translation);
        }
    }
    
    private void notifyTranslationError(String original, String error) {
        for (TranslationListener listener : listeners) {
            listener.onTranslationError(original, error);
        }
    }
}