# Get Started - Android

{% hint style="warning" %}
**Before you get started:** Make sure you have [**created a channel in OneTalk dashboard**](https://docs.taptalk.io/onetalk-omnichannel-documentation/onetalk-channel-integration/live-chat/..#setup-live-chat-for-android) and obtain the **`APP_KEY_SECRET.`** 
{% endhint %}

### Configure and Initialize TapTalk.io Omnichannel Android SDK for Flutter project

#### Step 1: Open Flutter project's android folder in Android Studio

To begin, open the **android** folder inside your Flutter project root folder as a project using Android Studio. Once all gradle dependencies are downloaded, we will follow the first step of OneTalk Android Live Chat implementation by installing the *omnichannel* SDK for the android project.

#### Step 2: Install TapTalk.io Omnichannel SDK

To start, open your Android project and add the following repositories to your **top-level build.gradle** file.

{% code title="build.gradle (project)" %}

```javascript
allprojects {
    repositories {
        google()
        jcenter()
        maven { url 'https://jitpack.io' }
        maven { url "https://s3.amazonaws.com/repo.commonsware.com" }
    }
}
```

{% endcode %}

Then add the following dependency to your **app-level** build.gradle:

{% code title="build.gradle (:app)" %}

```javascript
dependencies {
    implementation 'com.github.taptalk-io:taptalk.io-omnichannel-android:2.6.2'
}
```

{% endcode %}

{% hint style="info" %}
You can check a more updated version release notes of the SDK [here](https://github.com/taptalk-io/taptalk.io-omnichannel-android/releases).
{% endhint %}

{% hint style="warning" %}
**Note**: In the app **build.gradle** file, make sure that your project is using supported Java 8 language features under the `android` tag like below
{% endhint %}

{% code title="build.gradle (:app)" %}

```javascript
android {
    
    ...

    compileOptions {
        sourceCompatibility JavaVersion.VERSION_17
        targetCompatibility JavaVersion.VERSION_17
    }
}
```

{% endcode %}

{% hint style="warning" %}
Note: If you are getting a dex error when building the project (e.g. `Cannot fit requested classes in a single dex file`), try to enable multidex in the app **build.gradle** file.
{% endhint %}

{% code title="build.gradle (:app)" %}

```javascript
android {
    
    ...

    defaultConfig {
        ...
        multiDexEnabled true
    }
}
```

{% endcode %}

After adding the required dependency, sync your project and begin the next step by writing custom platform-specific code using platform channels.

#### Step 3: Create Flutter Platform Client

If you have finished this step from the [iOS side](https://docs.taptalk.io/onetalk-omnichannel-documentation/onetalk-channel-integration/live-chat/get-started-ios#step-6-create-flutter-platform-client), you can skip to the [next step](#step-3-add-an-android-platform-specific-implementation).

In this example, we will add the following inside the MyHomePageState class:

1. Method Channel to connect to the native Android host
2. `openOneTalkLiveChatTalkUI()` function to open the Live Chat's view
3. A button to call the `openOneTalkLiveChatTalkUI()` function

{% tabs %}
{% tab title="Dart" %}
{% code title="main.dart" %}

```dart
class _MyHomePageState extends State<MyHomePage> {
  
  // Create the MethodChannel
  static const oneTalkLiveChatMethodChannel = MethodChannel('io.taptalk.onetalklivechat');
  
  // Function to open the live chat view
  Future<void> _openOneTalkLiveChatTalkUI() async {
    try {
      // Initialize OneTalk Live Chat SDK
      final bool isOneTalkInitialized = await oneTalkLiveChatMethodChannel.invokeMethod('initOneTalkLiveChat');
      if (isOneTalkInitialized) {
        // Open live chat view
        await oneTalkLiveChatMethodChannel.invokeMethod('openLiveChatView');
      }
    }
    on PlatformException catch (e) {
      // Call might fail if the platform doesn’t support the platform API
      print(e.message);
    }
  }
  
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      ...
      body:
        ...
          // Sample button to call openOneTalkLiveChatTalkUI
          ElevatedButton(
            onPressed: _openOneTalkLiveChatTalkUI,
            child: Text(
              'Get Started with OneTalk Live Chat',
            ),
          ),
      ...
    );
  }
}
```

{% endcode %}
{% endtab %}
{% endtabs %}

Please note the name parameter in the MethodChannel constructor that was used (`io.taptalk.onetalklivechat`), and the method name in the `invokeMethod()` parameter (`initOneTalkLiveChat` & `openLiveChatView`). We will use the same names later to configure Flutter engine in the native side.

#### Step 4: Add an Android platform-specific implementation <a href="#step-3-add-an-android-platform-specific-implementation" id="step-3-add-an-android-platform-specific-implementation"></a>

Next, we will configure the native side of the Android host implementation. Go back to previously opened Android Studio project, and open **MainActivity** file. We will do the following to the Activity:

1. Add a MethodChannel Result variable to handle asynchronous call
2. override `configureFlutterEngine` to handle calls from the MethodChannel that we previously created.
3. Add native functions to init OneTalk Live Chat SDK and open the live chat view

{% tabs %}
{% tab title="Java" %}
{% code title="MainActivity.java" %}

```java
import io.taptalk.taptalklive.TapTalkLive;
import io.taptalk.taptalklive.Listener.TapTalkLiveListener;

public class MainActivity extends FlutterActivity {

    // MethodChannel Result to handle asynchronous call
    private MethodChannel.Result oneTalkMethodChannelResult = null;

    // Override configureFlutterEngine
    @Override
    public void configureFlutterEngine(@NonNull FlutterEngine flutterEngine) {
        super.configureFlutterEngine(flutterEngine);
        
        // Handle MethodChannel calls
        new MethodChannel(flutterEngine.getDartExecutor().getBinaryMessenger(), "io.taptalk.onetalklivechat")
            .setMethodCallHandler((call, result) -> {
                // Save result to variable
                oneTalkMethodChannelResult = result;
                switch (call.method) {
                    // Call native methods
                    case "initOneTalkLiveChat":
                        initOneTalkLiveChat();
                        break;
                    case "openLiveChatView":
                        openLiveChatView();
                        break;
                    default:    
                        result.notImplemented();
                }
            }
        );
    }
    
    // Method to initialize OneTalk Live Chat SDK
    private void initOneTalkLiveChat() {
        TapTalkLive.init(
            getApplicationContext(),
            ONETALK_APP_KEY_SECRET,
            R.drawable.your_app_icon,
            getString(R.string.your_app_name),
            new TapTalkLiveListener() {
                @Override
                public void onInitializationCompleted() {
                    if (oneTalkMethodChannelResult != null) {
                        oneTalkMethodChannelResult.success(true);
                    }
                }
            }
        );
    }

    // Method to open live chat view
    private void openLiveChatView() {
        boolean isSuccess = TapTalkLive.openTapTalkLiveView(this);
        if (oneTalkMethodChannelResult != null) {
            oneTalkMethodChannelResult.success(true);
        }
    }
}
```

{% endcode %}
{% endtab %}

{% tab title="Kotlin" %}
{% code title="MainActivity.kt" %}

```kotlin
import io.taptalk.taptalklive.TapTalkLive
import io.taptalk.taptalklive.Listener.TapTalkLiveListener

class MainActivity: FlutterActivity() {

    // MethodChannel Result to handle asynchronous call
    private var oneTalkMethodChannelResult: MethodChannel.Result? = null

    // Override configureFlutterEngine
    override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
        super.configureFlutterEngine(flutterEngine)

        // Handle MethodChannel calls
        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, "io.taptalk.onetalklivechat")
            .setMethodCallHandler {
                call, result ->
                // Save result to variable
                oneTalkMethodChannelResult = result
                when (call.method) {
                    // Call native methods
                    "initOneTalkLiveChat" -> initOneTalkLiveChat()
                    "openLiveChatView" -> openLiveChatView()
                    else -> result.notImplemented()
                }
            }
    }
    
    // Method to initialize OneTalk Live Chat SDK
    private fun initOneTalkLiveChat() {
        TapTalkLive.init(
            applicationContext,
            ONETALK_APP_KEY_SECRET,
            R.drawable.your_app_icon,
            getString(R.string.your_app_name),
            object : TapTalkLiveListener() {
                override fun onInitializationCompleted() {
                    oneTalkMethodChannelResult?.success(true)
                }
            }
        )
    }

    // Method to open live chat view
    private fun openLiveChatView() {
        val isSuccess = TapTalkLive.openTapTalkLiveView(this)
        oneTalkMethodChannelResult?.success(isSuccess)
    }
}
```

{% endcode %}
{% endtab %}
{% endtabs %}

{% hint style="info" %}
**`openTapTalkLiveView`** will return **`true`** if opening the view is successful, and will return `false` if it fails due to incomplete initialization. TapTalkLive initialization might not be completed if the device is not connected to internet or an incorrect **`APP_KEY_SECRET`** parameter was provided.
{% endhint %}

#### Step 5: Enable Chat Features

Please follow the steps in [Enable Chat Features](https://docs.taptalk.io/powertalk-chat-sdk-documentation/powertalk-android/enable-chat-features) page to enable TapTalk.io's chat features, such as contact sync and sending media, document, and location messages.

You can now try running the app. Pressing the sample button will invoke the `openOneTalkLiveChatTalkUI()` method that we previously created, which will initialize OneTalk Live Chat SDK, and open the live chat view once the initialization is completed. You may also try a different implementation and separate the **init** and the **open view** methods. You can also add more calls to other native methods with the same approach using the same MethodChannel.

{% hint style="info" %}
**Note**: You can check a more complete implementation guide in the [OneTalk Live Chat for Android](https://docs.taptalk.io/onetalk-omnichannel-documentation/onetalk-channel-integration/live-chat/onetalk-android) section.
{% endhint %}