使用Android创建日历服务'；s用户Google帐户管理器

我想从Android的GoogleAccountManager获得授权，然后以某种方式创建一个GoogleAPI服务来使用GoogleCalendar。我可以运行AccountManager，但我的问题是，在运行AccountManager并获得授权后，如何使用这些授权创建一个服务来访问Google日历？我得到的结果是：

com.google.api.client.googleapis.json.GoogleJsonResponseException: 403 Forbidden
{
 "code" : 403,
 "errors" : [ {
 "domain" : "usageLimits",
 "message" : "Daily Limit Exceeded. Please sign up",
 "reason" : "dailyLimitExceededUnreg",
 "extendedHelp" : "https://code.google.com/apis/console"
} ],
 "message" : "Daily Limit Exceeded. Please sign up"
}
at  com.google.api.client.googleapis.services.GoogleClient.execute(GoogleClient.java:123) 
...

使用此代码：

public final class CalendarSample extends Activity {

public static final String ROOT_URL = "https://www.googleapis.com/calendar/v3";
/** Logging level for HTTP requests/responses. */
private static Level LOGGING_LEVEL = Level.CONFIG;
private static final String AUTH_TOKEN_TYPE = "cl";
private static final String TAG = "CalendarSample";
private static final int MENU_ADD = 0;
private static final int MENU_ACCOUNTS = 1;
private static final int CONTEXT_EDIT = 0;
private static final int CONTEXT_DELETE = 1;
private static final int REQUEST_AUTHENTICATE = 0;

public int selectedCalendarIndex = 0;
public ListView calendarList;

final HttpTransport transport = AndroidHttp.newCompatibleTransport();
JacksonFactory jsonFactory = new JacksonFactory();

String accountName;

static final String PREF = TAG;
static final String PREF_ACCOUNT_NAME = "accountName";
static final String PREF_AUTH_TOKEN = "authToken";
static final String PREF_GSESSIONID = "gsessionid";
GoogleAccountManager accountManager;
SharedPreferences settings;
CalendarAndroidRequestInitializer requestInitializer;
com.google.api.services.calendar.Calendar service;

public class CalendarAndroidRequestInitializer extends CalendarRequestInitializer {

    String authToken;

    public CalendarAndroidRequestInitializer() {
        super(transport);
        authToken = settings.getString(PREF_AUTH_TOKEN, null);
        setGsessionid(settings.getString(PREF_GSESSIONID, null));
    }

    @Override
    public void intercept(HttpRequest request) throws IOException {
        super.intercept(request); request.getHeaders().setAuthorization(GoogleHeaders.getGoogleLoginValue(authToken));
    }

    @Override
    public boolean handleResponse(HttpRequest request, HttpResponse response, boolean retrySupported)
    throws IOException {
        switch (response.getStatusCode()) {
        case 302:
            super.handleResponse(request, response, retrySupported);
            SharedPreferences.Editor editor = settings.edit();
            editor.putString(PREF_GSESSIONID, getGsessionid());
            editor.commit();
            return true;
        case 401:
            accountManager.invalidateAuthToken(authToken);
            authToken = null;
            SharedPreferences.Editor editor2 = settings.edit();
            editor2.remove(PREF_AUTH_TOKEN);
            editor2.commit();
            return false;
        }
        return false;
    }
} 

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.calendar_main);
    Logger.getLogger("com.google.api.client").setLevel(LOGGING_LEVEL);
    accountManager = new GoogleAccountManager(this);
    settings = this.getSharedPreferences(PREF, 0);
    class InitializeTask extends AsyncTask<Void, Integer, Void> {
        @Override
        protected Void doInBackground(Void... arg0) {
            requestInitializer = new CalendarAndroidRequestInitializer();

                            //I think the problem occurs here. I am doing something wrong maybe.
            service = Calendar.builder(transport, jsonFactory)
                        .setApplicationName("YOUR_APPLICATION_NAME")
                        .setHttpRequestInitializer(requestInitializer)
                        .build();    
            return null;
        }
        @Override
        protected void onPostExecute(Void eventFeed) {
        }
    }
    AsyncTask<Void, Integer, Void> t = new InitializeTask().execute();
    try {
        t.get();
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (ExecutionException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();

    }   
    calendarList = (ListView) findViewById(R.id.calendar_list);
    calendarList.setTextFilterEnabled(true);
    calendarList.setOnItemClickListener(new OnItemClickListener() {
        public void onItemClick(AdapterView<?> arg0, View arg1, int pos, long arg3) {
            selectedCalendarIndex = pos;
            executeRefreshCalendars();
        }
    });

    gotAccount();
}

void setAuthToken(String authToken) {
    SharedPreferences.Editor editor = settings.edit();
    editor.putString(PREF_AUTH_TOKEN, authToken);
    editor.commit();
    requestInitializer.authToken = authToken;
}

void setAccountName(String accountName) {
    SharedPreferences.Editor editor = settings.edit();
    editor.putString(PREF_ACCOUNT_NAME, accountName);
    editor.remove(PREF_GSESSIONID);
    editor.commit();
    this.accountName = accountName;
    requestInitializer.setGsessionid(null);
}

private void gotAccount() {
    Account account = accountManager.getAccountByName(accountName);
    if (account != null) {
        // handle invalid token
        if (requestInitializer.authToken == null) {
            accountManager.manager.getAuthToken(account, AUTH_TOKEN_TYPE, true,
                    new AccountManagerCallback<Bundle>() {

                public void run(AccountManagerFuture<Bundle> future) {
                    try {
                        Bundle bundle = future.getResult();
                        if (bundle.containsKey(AccountManager.KEY_INTENT)) {
                            Intent intent = bundle.getParcelable(AccountManager.KEY_INTENT);
                            int flags = intent.getFlags();
                            flags &= ~Intent.FLAG_ACTIVITY_NEW_TASK;
                            intent.setFlags(flags);
                            startActivityForResult(intent, REQUEST_AUTHENTICATE);
                        } else if (bundle.containsKey(AccountManager.KEY_AUTHTOKEN)) {
                            setAuthToken(bundle.getString(AccountManager.KEY_AUTHTOKEN));
                            executeRefreshCalendars();
                        }
                    } catch (Exception e) {
                        handleException(e);
                    }
                }
            }, null);
        } else {
            executeRefreshCalendars();
        }
        return;
    }
    chooseAccount();
}

private void chooseAccount() {
    accountManager.manager.getAuthTokenByFeatures(GoogleAccountManager.ACCOUNT_TYPE,
            AUTH_TOKEN_TYPE, null, CalendarSample.this, null, null,
            new AccountManagerCallback<Bundle>() {

        public void run(AccountManagerFuture<Bundle> future) {
            Bundle bundle;
            try {
                bundle = future.getResult();
                setAccountName(bundle.getString(AccountManager.KEY_ACCOUNT_NAME));
                setAuthToken(bundle.getString(AccountManager.KEY_AUTHTOKEN));
                executeRefreshCalendars();
            } catch (OperationCanceledException e) {
                // user canceled
            } catch (AuthenticatorException e) {
                handleException(e);
            } catch (IOException e) {
                handleException(e);
            }
        }
    }, null);
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    switch (requestCode) {
    case REQUEST_AUTHENTICATE:
        if (resultCode == RESULT_OK) {
            gotAccount();
        } else {
            chooseAccount();
        }
        break;
    }
}

void executeRefreshCalendars() {
    class ExecuteRefreshCalendarTask extends AsyncTask<Void, Integer, Void> {
        Activity activity;
        public ExecuteRefreshCalendarTask(Activity activity) {
          this.activity = activity;
        }
        @Override
        protected Void doInBackground(Void... arg0) {
            com.google.api.services.calendar.model.Calendar calendar;
            try {
                calendar = service.calendars().get("primary").execute();
                System.out.println(calendar.getSummary()); // here I want to print title of calendars to see if it is running correctly
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }               
            return null;
        }
        @Override
        protected void onPostExecute(Void eventFeed) {      
        }
    AsyncTask<Void, Integer, Void> task = new ExecuteRefreshCalendarTask(this).execute();
}

void handleException(Exception e) {
    e.printStackTrace();
    if (e instanceof HttpResponseException) {
        HttpResponse response = ((HttpResponseException) e).getResponse();
        int statusCode = response.getStatusCode();
        try {
            response.ignore();
        } catch (IOException e1) {
            e1.printStackTrace();
        }
        // TODO(yanivi): should only try this once to avoid infinite loop
        if (statusCode == 401) {
            gotAccount();
            return;
        }
        try {
            Log.e(TAG, response.parseAsString());
        } catch (IOException parseException) {
            parseException.printStackTrace();
        }
    }
    Log.e(TAG, e.getMessage(), e);
}
}

公共最终类日历示例扩展活动{
公共静态最终字符串ROOT_URL=”https://www.googleapis.com/calendar/v3";
/**HTTP请求/响应的日志记录级别*/
私有静态级别日志记录\u Level=Level.CONFIG；
私有静态最终字符串AUTH_TOKEN_TYPE=“cl”；
私有静态最终字符串TAG=“CalendarSample”；
专用静态最终整数菜单_ADD=0；
私有静态最终int菜单_账户=1；
私有静态final int CONTEXT_EDIT=0；
私有静态final int CONTEXT_DELETE=1；
私有静态最终int请求_AUTHENTICATE=0；
public int selectedCalendarIndex=0；
公共列表视图日历列表；
final HttpTransport transport=AndroidHttp.newCompatibleTransport（）；
JacksonFactory jsonFactory=新JacksonFactory（）；
字符串accountName；
静态最终字符串PREF=标记；
静态最终字符串PREF\u ACCOUNT\u NAME=“accountName”；
静态最终字符串PREF\u AUTH\u TOKEN=“authToken”；
静态最终字符串PREF_GSESSIONID=“GSESSIONID”；
谷歌会计经理；
共享引用设置；
CalendarAndroidRequestInitializer请求初始值设定项；
com.google.api.services.calendar.calendar服务；
公共类CalendarAndroidRequestInitializer扩展CalendarRequestInitializer{
字符串authToken；
公共日历AndroidRequestInitializer（）{
超级(运输);；
authToken=settings.getString（PREF_AUTH_TOKEN，null）；
setGsessionid（settings.getString（PREF_GSESSIONID，null））；
}
@凌驾
公共无效截获（HttpRequest请求）引发IOException{
super.intercept（request）；request.getHeaders（）.setAuthorization（GoogleHeaders.getGoogleLoginValue（authToken））；
}
@凌驾
公共布尔handleResponse（支持HttpRequest请求、HttpResponse响应、布尔retrySupported）
抛出IOException{
开关（response.getStatusCode（））{
案例302：
超级HandlerResponse（请求、响应、回复支持）；
SharedReferences.Editor=settings.edit（）；
putString（PREF_GSESSIONID，getGsessionid（））；
commit（）；
返回true；
案例401：
accountManager.invalidateAuthToken（authToken）；
authToken=null；
SharedReferences.Editor editor2=settings.edit（）；
editor2.删除（PREF_AUTH_令牌）；
editor2.commit（）；
返回false；
}
返回false；
}
} 
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.calendar\u main）；
Logger.getLogger（“com.google.api.client”）.setLevel（LOGGING_-LEVEL）；
accountManager=新的GoogleAccountManager（此）；
设置=this.getSharedReferences（PREF，0）；
类InitializeTask扩展了AsyncTask{
@凌驾
受保护的Void doInBackground（Void…arg0）{
requestInitializer=新日历AndRoidRequestInitializer（）；
//我想问题就在这里。我可能做错了什么。
service=Calendar.builder（运输、jsonFactory）
.setApplicationName（“您的应用程序名称”）
.setHttpRequestInitializer（请求初始值设定项）
.build（）；
返回null；
}
@凌驾
受保护的void onPostExecute（void eventFeed）{
}
}
AsyncTask t=new InitializeTask（）.execute（）；
试一试{
t、 get（）；
}捕捉（中断异常e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}捕获（执行例外）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}   
calendarList=（ListView）findViewById（R.id.calendar\u列表）；
calendarList.setTextFilterEnabled（true）；
calendarList.setOnItemClickListener（新的OnItemClickListener（）{
公共链接（AdapterView arg0、视图arg1、内部位置、长arg3）{
selectedCalendarIndex=pos；
executeRefreshCalendars（）；
}
});
gotcount（）；
}
void setAuthToken（字符串authToken）{
SharedReferences.Editor=settings.edit（）；
putString（PREF_AUTH_令牌，authToken）；
commit（）；
requestInitializer.authToken=authToken；
}
void setAccountName（字符串accountName）{
SharedReferences.Editor=settings.edit（）；
编辑器.putString（PREF_ACCOUNT_NAME，accountName）；
editor.remove（PREF_gsession id）；
commit（）；
this.accountName=accountName；
requestInitializer.setGsessionid（null）；
}
私人帐户（）{
Account=accountManager.getAccountByName（accountName）；
如果（帐户！=null）{
//处理无效令牌
if（requestInitializer.authToken==null）{
accountManager.manager.getAuthToken（帐户，身份验证令牌类型，true，
新建AccountManagerCallback（）{
公共作废运行（AccountManagerFuture）{
试一试{
Bundle=future.getResult（）；
if（bundle.containsKey（AccountManager.KEY_INTENT））{
Intent Intent=bundle.getParcelable（AccountManager.KEY\u Intent）；
int flags=intent.getFlags（）；
标志&=~Intent.FLAG\u活动\u新任务；
意图。设置标志（标志）；
startActivityForResult（意图、请求和验证）；
}否则