Home » Android » android – IllegalArgumentException: addAccount not supported

android – IllegalArgumentException: addAccount not supported

Posted by: admin June 15, 2020 Leave a comment

Questions:

I followed this description to add my sync adapter.

But there is a litte bug 🙁

When I open Settings -> Account -> Add account and select my account I get this error message

java.lang.IllegalArgumentException: addAccount not supported
    at android.accounts.AccountManager.convertErrorToException(AccountManager.java:2147)
    at android.accounts.AccountManager.-wrap0(AccountManager.java)
    at android.accounts.AccountManager$AmsTask$Response.onError(AccountManager.java:1993)
    at android.accounts.IAccountManagerResponse$Stub.onTransact(IAccountManagerResponse.java:69)
    at android.os.Binder.execTransact(Binder.java:453)

It looks that this crash comes from converting the Authenticator Java class to a Kotlin class.

The Java class locks like this

public class Authenticator extends AbstractAccountAuthenticator {

    private final Context mContext;

    // Simple constructor
    public Authenticator(Context context) {

        super(context);
        mContext = context;
    }

    // Editing properties is not supported
    @Override
    public Bundle editProperties(AccountAuthenticatorResponse response,
                                 String accountType) {

        throw new UnsupportedOperationException();
    }

    @Override
    public Bundle addAccount(AccountAuthenticatorResponse response, String accountType,
                             String authTokenType, String[] requiredFeatures, Bundle options)
            throws NetworkErrorException {

        SyncUtilsKt.createSyncAccount(mContext);

        final Bundle bundle = new Bundle();
        bundle.putString(AccountManager.KEY_ACCOUNT_NAME, ConstantsKt.SYNC_ACCOUNT);
        bundle.putString(AccountManager.KEY_ACCOUNT_TYPE, BuildConfig.ACCOUNT_TYPE);

        return bundle;
    }

    // Ignore attempts to confirm credentials
    @Override
    public Bundle confirmCredentials(AccountAuthenticatorResponse response,
                                     Account account, Bundle options)
            throws NetworkErrorException {

        return null;
    }

    // Getting an authentication token is not supported
    @Override
    public Bundle getAuthToken(AccountAuthenticatorResponse response,
                               Account account, String authTokenType, Bundle options)
            throws NetworkErrorException {

        throw new UnsupportedOperationException();
    }

    // Getting a label for the auth token is not supported
    @Override
    public String getAuthTokenLabel(String authTokenType) {

        throw new UnsupportedOperationException();
    }

    // Updating user credentials is not supported
    @Override
    public Bundle updateCredentials(AccountAuthenticatorResponse response,
                                    Account account, String authTokenType, Bundle options) throws NetworkErrorException {

        throw new UnsupportedOperationException();
    }

    // Checking features for the account is not supported
    @Override
    public Bundle hasFeatures(AccountAuthenticatorResponse response,
                              Account account, String[] features) throws NetworkErrorException {

        throw new UnsupportedOperationException();
    }
}

After converting it to Kotlin it locks like this:

class Authenticator(private val mContext: Context) : AbstractAccountAuthenticator(mContext) {

    // Editing properties is not supported
    override fun editProperties(response: AccountAuthenticatorResponse,
                                accountType: String): Bundle {

        throw UnsupportedOperationException()
    }

    @Throws(NetworkErrorException::class)
    override fun addAccount(response: AccountAuthenticatorResponse, accountType: String,
                            authTokenType: String, requiredFeatures: Array<String>, options: Bundle): Bundle {

        createSyncAccount(mContext)

        val bundle = Bundle()
        bundle.putString(AccountManager.KEY_ACCOUNT_NAME, SYNC_ACCOUNT)
        bundle.putString(AccountManager.KEY_ACCOUNT_TYPE, BuildConfig.ACCOUNT_TYPE)

        return bundle
    }

    // Ignore attempts to confirm credentials
    @Throws(NetworkErrorException::class)
    override fun confirmCredentials(response: AccountAuthenticatorResponse,
                                    account: Account, options: Bundle): Bundle? {

        return null
    }

    // Getting an authentication token is not supported
    @Throws(NetworkErrorException::class)
    override fun getAuthToken(response: AccountAuthenticatorResponse,
                              account: Account, authTokenType: String, options: Bundle): Bundle {

        throw UnsupportedOperationException()
    }

    // Getting a label for the auth token is not supported
    override fun getAuthTokenLabel(authTokenType: String): String {

        throw UnsupportedOperationException()
    }

    // Updating user credentials is not supported
    @Throws(NetworkErrorException::class)
    override fun updateCredentials(response: AccountAuthenticatorResponse,
                                   account: Account, authTokenType: String, options: Bundle): Bundle {

        throw UnsupportedOperationException()
    }

    // Checking features for the account is not supported
    @Throws(NetworkErrorException::class)
    override fun hasFeatures(response: AccountAuthenticatorResponse,
                             account: Account, features: Array<String>): Bundle {

        throw UnsupportedOperationException()
    }
}

I think there is something was wrong converted but what?

How to&Answers:

I found my mistake. The addAccount method needs some annotations. Finally it looks like this:

@Throws(NetworkErrorException::class)
override fun addAccount(response: AccountAuthenticatorResponse,
                        accountType: String,
                        authTokenType: String?,
                        requiredFeatures: Array<String>?,
                        options: Bundle?): Bundle? {

    val accountManager = mContext.getSystemService(Context.ACCOUNT_SERVICE) as AccountManager
    val accounts = accountManager.getAccountsByType("example.com")
    if (accounts.size == 0) {
        val newAccount = Account("Sync Account", "example.com")
        accountManager.addAccountExplicitly(newAccount, null, null)
    }

    val bundle = Bundle()
    bundle.putString(AccountManager.KEY_ACCOUNT_NAME, "Sync Account")
    bundle.putString(AccountManager.KEY_ACCOUNT_TYPE, "example.com")

    return bundle
}

Answer:

For Kotlin make sure you have nullable type parameters.

This is wrong:

@Throws(NetworkErrorException::class)
override fun addAccount(
response: AccountAuthenticatorResponse, accountType: String, authTokenType: 
String, requiredFeatures: Array<String>, options: Bundle): Bundle {

val bundle = Bundle()
val intent = Intent(context, LoginActivity::class.java)
intent.putExtra(SessionConstants.GO_ACCOUNT_TYPE, accountType)
intent.putExtra(SessionConstants.GO_AUTH_TOKEN_TYPE, authTokenType)
intent.putExtra(SessionConstants.GO_IS_ADDING_NEW_ACCOUNT, true)

intent.putExtra(AccountManager.KEY_ACCOUNT_AUTHENTICATOR_RESPONSE, response)
bundle.putParcelable(AccountManager.KEY_INTENT, intent)
return bundle
}

Look at the parameters, they are nonnull in the above code. Which throws

java.lang.IllegalArgumentException: addAccount not supported
at android.accounts.AccountManager.convertErrorToException(AccountManager.java:2147)
at android.accounts.AccountManager.-wrap0(AccountManager.java)
at android.accounts.AccountManager$AmsTask$Response.onError(AccountManager.java:1993)
at android.accounts.IAccountManagerResponse$Stub.onTransact(IAccountManagerResponse.java:69)
at android.os.Binder.execTransact(Binder.java:453)

Following this the correct method definition:

 @Throws(NetworkErrorException::class)
 override fun addAccount(response: AccountAuthenticatorResponse?, 
 accountType: String?, authTokenType: String?, p3: Array<out String>?, p4: 
 Bundle?): Bundle {
val bundle = Bundle()
val intent = Intent(context, LoginActivity::class.java)
intent.putExtra(SessionConstants.GO_ACCOUNT_TYPE, accountType)
intent.putExtra(SessionConstants.GO_AUTH_TOKEN_TYPE, authTokenType)
intent.putExtra(SessionConstants.GO_IS_ADDING_NEW_ACCOUNT, true)

intent.putExtra(AccountManager.KEY_ACCOUNT_AUTHENTICATOR_RESPONSE, response)
bundle.putParcelable(AccountManager.KEY_INTENT, intent)
return bundle

}

Answer:

You can leave out the network exception. But the parameters need to be nullable