GoogleAuthUtil.getToken returns null and gets com.google.android.gms.auth.GoogleAuthException: unknown genrated

This is my code:
Main activity:

    public class MainActivity extends Activity implements OnClickListener   {

    private static final String TAG = "PlayHelloActivity";
   // This client id
            public static String TYPE_KEY = "997914232893-4f2dggarutugl7r945jblef441mia28f.apps.googleusercontent.com";
         private static final String SCOPE = "audience:server:client_id:"+TYPE_KEY+":api_scope:https://www.googleapis.com/auth/userinfo.profile";

        private String mEmail;
        ProgressDialog  mDialog;

        String providerName;
        private AlertDialog dialog;


        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);


            findViewById(R.id.sign_in_button).setOnClickListener(this);

        }

        @Override
        public void onClick(View v) {
            // TODO Auto-generated method stub
            getUsername();

        }
         @Override
            protected void onActivityResult(int requestCode, int resultCode, Intent data) {
             super.onActivityResult(requestCode, resultCode, data);
                if (requestCode == REQUEST_CODE_PICK_ACCOUNT) {
                    if (resultCode == RESULT_OK) {
                        mEmail = data.getStringExtra(AccountManager.KEY_ACCOUNT_NAME);
                        Log.e("email", ""+mEmail);
                        getUsername();

                    } else if (resultCode == RESULT_CANCELED) {
                        Toast.makeText(this, "You must pick an account", Toast.LENGTH_SHORT).show();
                    }
                } else if ((requestCode == REQUEST_CODE_RECOVER_FROM_AUTH_ERROR ||
                        requestCode == REQUEST_CODE_RECOVER_FROM_PLAY_SERVICES_ERROR)
                        && resultCode == RESULT_OK) {
                    handleAuthorizeResult(resultCode, data);
                    return;
                }

            }


         /** Attempt to get the user name. If the email address isn't known yet,
             * then call pickUserAccount() method so the user can pick an account.
             */
            private void getUsername() {

           if (mEmail == null) {
                    pickUserAccount();
                } else {
                    if (isDeviceOnline()) {
                        new GetNameInForeground(MainActivity.this, mEmail, SCOPE).execute();

                    } else {
                        Toast.makeText(this, "No network connection available", Toast.LENGTH_SHORT).show();
                    }
                }
            }
            /** Starts an activity in Google Play Services so the user can pick an account */
            private void pickUserAccount() {
                String[] accountTypes = new String[]{"com.google"};
                Intent intent = AccountPicker.newChooseAccountIntent(null, null,
                        accountTypes, false, null, null, null, null);
                startActivityForResult(intent, REQUEST_CODE_PICK_ACCOUNT);
            }
            /** Checks whether the device currently has a network connection */
            private boolean isDeviceOnline() {
                ConnectivityManager connMgr = (ConnectivityManager)
                        getSystemService(Context.CONNECTIVITY_SERVICE);
                NetworkInfo networkInfo = connMgr.getActiveNetworkInfo();
                if (networkInfo != null && networkInfo.isConnected()) {
                    return true;
                }
                return false;
            }


            private void handleAuthorizeResult(int resultCode, Intent data) {
                if (data == null) {
                  //  show("Unknown error, click the button again");
                    return;
                }
                if (resultCode == RESULT_OK) {
                    Log.i(TAG, "Retrying");
                    new GetNameInForeground(MainActivity.this, mEmail, SCOPE).execute();
                    return;
                }
                if (resultCode == RESULT_CANCELED) {
                   // show("User rejected authorization.");
                    return;
                }
               // show("Unknown error, click the button again");
            }
            /**
             * This method is a hook for background threads and async tasks that need to provide the
             * user a response UI when an exception occurs.
             */
            public void handleException(final Exception e) {
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        if (e instanceof GooglePlayServicesAvailabilityException) {
                            // The Google Play services APK is old, disabled, or not present.
                            // Show a dialog created by Google Play services that allows
                            // the user to update the APK
                            int statusCode = ((GooglePlayServicesAvailabilityException)e)
                                    .getConnectionStatusCode();
                            Dialog dialog = GooglePlayServicesUtil.getErrorDialog(statusCode,
                                    MainActivity.this,
                                    REQUEST_CODE_RECOVER_FROM_PLAY_SERVICES_ERROR);
                            dialog.show();
                        } else if (e instanceof UserRecoverableAuthException) {
                            // Unable to authenticate, such as when the user has not yet granted
                            // the app access to the account, but the user can fix this.
                            // Forward the user to an activity in Google Play services.
                            Intent intent = ((UserRecoverableAuthException)e).getIntent();
                            startActivityForResult(intent,
                                    REQUEST_CODE_RECOVER_FROM_PLAY_SERVICES_ERROR);
                        }
                    }
                });
            }
}

      

        
        
        
      

    

This is the requirement to get a token:

public class GetNameInForeground extends AbstractGetNameTask {

  private static final String REQUEST_CODE_AUTH_GOOGLE_ACCOUNT = null;


public GetNameInForeground(MainActivity activity, String email, String scope) {
      super(activity, email, scope);
  }


  /**
   * Get a authentication token if one is not available. If the error is not recoverable then
   * it displays the error message on parent activity right away.
   */
  @Override
  protected String fetchToken() throws IOException {
      try {
           String token= GoogleAuthUtil.getToken(mActivity, mEmail, mScope);
         return token;

      } catch ( UserRecoverableAuthException userRecoverableException) {


          mActivity.handleException(userRecoverableException);
      } catch ( GoogleAuthException fatalException) {
         onError("Unrecoverable error" + fatalException.getMessage(), fatalException);
      }
      catch (IOException e) {
        // TODO: handle exception
    }

      return null;
  }


}

      

        
        
        
      

    

If I do not use the client ID in the scope url, then I will only get information about my account (which you signed up with a google developer account), whereas the client ID is used.