gametel 0.1

data/ApiDemos/src/com/example/android/apis/app/ActionBarUsage.java

@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.example.android.apis.app;
+
+import android.app.Activity;
+import android.graphics.drawable.Drawable;
+import android.os.Bundle;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.widget.SearchView;
+import android.widget.SearchView.OnQueryTextListener;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import com.example.android.apis.R;
+
+/**
+ * This demonstrates idiomatic usage of the Action Bar. The default Honeycomb theme
+ * includes the action bar by default and a menu resource is used to populate the
+ * menu data itself. If you'd like to see how these things work under the hood, see
+ * ActionBarMechanics.
+ */
+public class ActionBarUsage extends Activity implements OnQueryTextListener {
+    TextView mSearchText;
+    int mSortMode = -1;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        mSearchText = new TextView(this);
+        setContentView(mSearchText);
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        MenuInflater inflater = getMenuInflater();
+        inflater.inflate(R.menu.actions, menu);
+        SearchView searchView = (SearchView) menu.findItem(R.id.action_search).getActionView();
+        searchView.setOnQueryTextListener(this);
+        return true;
+    }
+
+    @Override
+    public boolean onPrepareOptionsMenu(Menu menu) {
+        if (mSortMode != -1) {
+            Drawable icon = menu.findItem(mSortMode).getIcon();
+            menu.findItem(R.id.action_sort).setIcon(icon);
+        }
+        return super.onPrepareOptionsMenu(menu);
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        Toast.makeText(this, "Selected Item: " + item.getTitle(), Toast.LENGTH_SHORT).show();
+        return true;
+    }
+
+    // This method is specified as an onClick handler in the menu xml and will
+    // take precedence over the Activity's onOptionsItemSelected method.
+    // See res/menu/actions.xml for more info.
+    public void onSort(MenuItem item) {
+        mSortMode = item.getItemId();
+        // Request a call to onPrepareOptionsMenu so we can change the sort icon
+        invalidateOptionsMenu();
+    }
+
+    // The following callbacks are called for the SearchView.OnQueryChangeListener
+    // For more about using SearchView, see src/.../view/SearchView1.java and SearchView2.java
+    public boolean onQueryTextChange(String newText) {
+        newText = newText.isEmpty() ? "" : "Query so far: " + newText;
+        mSearchText.setText(newText);
+        return true;
+    }
+
+    public boolean onQueryTextSubmit(String query) {
+        Toast.makeText(this, "Searching for: " + query + "...", Toast.LENGTH_SHORT).show();
+        return true;
+    }
+}

data/ApiDemos/src/com/example/android/apis/app/ActivityRecreate.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.apis.app;
+
+import com.example.android.apis.R;
+import com.example.android.apis.app.LocalServiceActivities.Controller;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+
+public class ActivityRecreate extends Activity {
+    int mCurTheme;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        if (savedInstanceState != null) {
+            mCurTheme = savedInstanceState.getInt("theme");
+
+            // Switch to a new theme different from last theme.
+            switch (mCurTheme) {
+                case android.R.style.Theme_Holo_Light:
+                    mCurTheme = android.R.style.Theme_Holo_Dialog;
+                    break;
+                case android.R.style.Theme_Holo_Dialog:
+                    mCurTheme = android.R.style.Theme_Holo;
+                    break;
+                default:
+                    mCurTheme = android.R.style.Theme_Holo_Light;
+                    break;
+            }
+            setTheme(mCurTheme);
+        }
+
+        setContentView(R.layout.activity_recreate);
+
+        // Watch for button clicks.
+        Button button = (Button)findViewById(R.id.recreate);
+        button.setOnClickListener(mRecreateListener);
+    }
+
+    @Override
+    protected void onSaveInstanceState(Bundle savedInstanceState) {
+        super.onSaveInstanceState(savedInstanceState);
+        savedInstanceState.putInt("theme", mCurTheme);
+    }
+
+    private OnClickListener mRecreateListener = new OnClickListener() {
+        public void onClick(View v) {
+            recreate();
+        }
+    };
+}

data/ApiDemos/src/com/example/android/apis/app/AlarmController.java

@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.apis.app;
+
+// Need the following import to get access to the app resources, since this
+// class is in a sub-package.
+import com.example.android.apis.R;
+
+import android.app.Activity;
+import android.app.AlarmManager;
+import android.app.PendingIntent;
+import android.content.Intent;
+import android.os.SystemClock;
+import android.os.Bundle;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.Toast;
+
+import java.util.Calendar;
+
+/**
+ * Example of scheduling one-shot and repeating alarms.  See
+ * {@link OneShotAlarm} for the code run when the one-shot alarm goes off, and
+ * {@link RepeatingAlarm} for the code run when the repeating alarm goes off.
+ * <h4>Demo</h4>
+App/Service/Alarm Controller
+ 
+<h4>Source files</h4>
+<table class="LinkTable">
+        <tr>
+            <td class="LinkColumn">src/com.example.android.apis/app/AlarmController.java</td>
+            <td class="DescrColumn">The activity that lets you schedule alarms</td>
+        </tr>
+        <tr>
+            <td class="LinkColumn">src/com.example.android.apis/app/OneShotAlarm.java</td>
+            <td class="DescrColumn">This is an intent receiver that executes when the
+                one-shot alarm goes off</td>
+        </tr>
+        <tr>
+            <td class="LinkColumn">src/com.example.android.apis/app/RepeatingAlarm.java</td>
+            <td class="DescrColumn">This is an intent receiver that executes when the
+                repeating alarm goes off</td>
+        </tr>
+        <tr>
+            <td class="LinkColumn">/res/any/layout/alarm_controller.xml</td>
+            <td class="DescrColumn">Defines contents of the screen</td>
+        </tr>
+</table>
+
+ */
+public class AlarmController extends Activity {
+    Toast mToast;
+
+    @Override
+	protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        setContentView(R.layout.alarm_controller);
+
+        // Watch for button clicks.
+        Button button = (Button)findViewById(R.id.one_shot);
+        button.setOnClickListener(mOneShotListener);
+        button = (Button)findViewById(R.id.start_repeating);
+        button.setOnClickListener(mStartRepeatingListener);
+        button = (Button)findViewById(R.id.stop_repeating);
+        button.setOnClickListener(mStopRepeatingListener);
+    }
+
+    private OnClickListener mOneShotListener = new OnClickListener() {
+        public void onClick(View v) {
+            // When the alarm goes off, we want to broadcast an Intent to our
+            // BroadcastReceiver.  Here we make an Intent with an explicit class
+            // name to have our own receiver (which has been published in
+            // AndroidManifest.xml) instantiated and called, and then create an
+            // IntentSender to have the intent executed as a broadcast.
+            Intent intent = new Intent(AlarmController.this, OneShotAlarm.class);
+            PendingIntent sender = PendingIntent.getBroadcast(AlarmController.this,
+                    0, intent, 0);
+
+            // We want the alarm to go off 30 seconds from now.
+            Calendar calendar = Calendar.getInstance();
+            calendar.setTimeInMillis(System.currentTimeMillis());
+            calendar.add(Calendar.SECOND, 30);
+
+            // Schedule the alarm!
+            AlarmManager am = (AlarmManager)getSystemService(ALARM_SERVICE);
+            am.set(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(), sender);
+
+            // Tell the user about what we did.
+            if (mToast != null) {
+                mToast.cancel();
+            }
+            mToast = Toast.makeText(AlarmController.this, R.string.one_shot_scheduled,
+                    Toast.LENGTH_LONG);
+            mToast.show();
+        }
+    };
+
+    private OnClickListener mStartRepeatingListener = new OnClickListener() {
+        public void onClick(View v) {
+            // When the alarm goes off, we want to broadcast an Intent to our
+            // BroadcastReceiver.  Here we make an Intent with an explicit class
+            // name to have our own receiver (which has been published in
+            // AndroidManifest.xml) instantiated and called, and then create an
+            // IntentSender to have the intent executed as a broadcast.
+            // Note that unlike above, this IntentSender is configured to
+            // allow itself to be sent multiple times.
+            Intent intent = new Intent(AlarmController.this, RepeatingAlarm.class);
+            PendingIntent sender = PendingIntent.getBroadcast(AlarmController.this,
+                    0, intent, 0);
+            
+            // We want the alarm to go off 30 seconds from now.
+            long firstTime = SystemClock.elapsedRealtime();
+            firstTime += 15*1000;
+
+            // Schedule the alarm!
+            AlarmManager am = (AlarmManager)getSystemService(ALARM_SERVICE);
+            am.setRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP,
+                            firstTime, 15*1000, sender);
+
+            // Tell the user about what we did.
+            if (mToast != null) {
+                mToast.cancel();
+            }
+            mToast = Toast.makeText(AlarmController.this, R.string.repeating_scheduled,
+                    Toast.LENGTH_LONG);
+            mToast.show();
+        }
+    };
+
+    private OnClickListener mStopRepeatingListener = new OnClickListener() {
+        public void onClick(View v) {
+            // Create the same intent, and thus a matching IntentSender, for
+            // the one that was scheduled.
+            Intent intent = new Intent(AlarmController.this, RepeatingAlarm.class);
+            PendingIntent sender = PendingIntent.getBroadcast(AlarmController.this,
+                    0, intent, 0);
+            
+            // And cancel the alarm.
+            AlarmManager am = (AlarmManager)getSystemService(ALARM_SERVICE);
+            am.cancel(sender);
+
+            // Tell the user about what we did.
+            if (mToast != null) {
+                mToast.cancel();
+            }
+            mToast = Toast.makeText(AlarmController.this, R.string.repeating_unscheduled,
+                    Toast.LENGTH_LONG);
+            mToast.show();
+        }
+    };
+}
+

data/ApiDemos/src/com/example/android/apis/app/AlarmService.java

@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.apis.app;
+
+// Need the following import to get access to the app resources, since this
+// class is in a sub-package.
+import com.example.android.apis.R;
+
+import android.app.Activity;
+import android.app.AlarmManager;
+import android.app.PendingIntent;
+import android.content.Intent;
+import android.os.SystemClock;
+import android.os.Bundle;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.Toast;
+
+
+/**
+ * This demonstrates how you can schedule an alarm that causes a service to
+ * be started.  This is useful when you want to schedule alarms that initiate
+ * long-running operations, such as retrieving recent e-mails.
+ */
+public class AlarmService extends Activity {
+    private PendingIntent mAlarmSender;
+    
+    @Override
+	protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        // Create an IntentSender that will launch our service, to be scheduled
+        // with the alarm manager.
+        mAlarmSender = PendingIntent.getService(AlarmService.this,
+                0, new Intent(AlarmService.this, AlarmService_Service.class), 0);
+        
+        setContentView(R.layout.alarm_service);
+
+        // Watch for button clicks.
+        Button button = (Button)findViewById(R.id.start_alarm);
+        button.setOnClickListener(mStartAlarmListener);
+        button = (Button)findViewById(R.id.stop_alarm);
+        button.setOnClickListener(mStopAlarmListener);
+    }
+
+    private OnClickListener mStartAlarmListener = new OnClickListener() {
+        public void onClick(View v) {
+            // We want the alarm to go off 30 seconds from now.
+            long firstTime = SystemClock.elapsedRealtime();
+
+            // Schedule the alarm!
+            AlarmManager am = (AlarmManager)getSystemService(ALARM_SERVICE);
+            am.setRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP,
+                            firstTime, 30*1000, mAlarmSender);
+
+            // Tell the user about what we did.
+            Toast.makeText(AlarmService.this, R.string.repeating_scheduled,
+                    Toast.LENGTH_LONG).show();
+        }
+    };
+
+    private OnClickListener mStopAlarmListener = new OnClickListener() {
+        public void onClick(View v) {
+            // And cancel the alarm.
+            AlarmManager am = (AlarmManager)getSystemService(ALARM_SERVICE);
+            am.cancel(mAlarmSender);
+
+            // Tell the user about what we did.
+            Toast.makeText(AlarmService.this, R.string.repeating_unscheduled,
+                    Toast.LENGTH_LONG).show();
+
+        }
+    };
+}

data/ApiDemos/src/com/example/android/apis/app/AlarmService_Service.java

@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.example.android.apis.app;
+
+// Need the following import to get access to the app resources, since this
+// class is in a sub-package.
+import com.example.android.apis.R;
+
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.Intent;
+import android.os.Binder;
+import android.os.IBinder;
+import android.os.Parcel;
+import android.os.RemoteException;
+import android.widget.Toast;
+
+/**
+ * This is an example of implementing an application service that will run in
+ * response to an alarm, allowing us to move long duration work out of an
+ * intent receiver.
+ * 
+ * @see AlarmService
+ * @see AlarmService_Alarm
+ */
+public class AlarmService_Service extends Service {
+    NotificationManager mNM;
+
+    @Override
+    public void onCreate() {
+        mNM = (NotificationManager)getSystemService(NOTIFICATION_SERVICE);
+
+        // show the icon in the status bar
+        showNotification();
+
+        // Start up the thread running the service.  Note that we create a
+        // separate thread because the service normally runs in the process's
+        // main thread, which we don't want to block.
+        Thread thr = new Thread(null, mTask, "AlarmService_Service");
+        thr.start();
+    }
+
+    @Override
+    public void onDestroy() {
+        // Cancel the notification -- we use the same ID that we had used to start it
+        mNM.cancel(R.string.alarm_service_started);
+
+        // Tell the user we stopped.
+        Toast.makeText(this, R.string.alarm_service_finished, Toast.LENGTH_SHORT).show();
+    }
+
+    /**
+     * The function that runs in our worker thread
+     */
+    Runnable mTask = new Runnable() {
+        public void run() {
+            // Normally we would do some work here...  for our sample, we will
+            // just sleep for 30 seconds.
+            long endTime = System.currentTimeMillis() + 15*1000;
+            while (System.currentTimeMillis() < endTime) {
+                synchronized (mBinder) {
+                    try {
+                        mBinder.wait(endTime - System.currentTimeMillis());
+                    } catch (Exception e) {
+                    }
+                }
+            }
+
+            // Done with our work...  stop the service!
+            AlarmService_Service.this.stopSelf();
+        }
+    };
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return mBinder;
+    }
+
+    /**
+     * Show a notification while this service is running.
+     */
+    private void showNotification() {
+        // In this sample, we'll use the same text for the ticker and the expanded notification
+        CharSequence text = getText(R.string.alarm_service_started);
+
+        // Set the icon, scrolling text and timestamp
+        Notification notification = new Notification(R.drawable.stat_sample, text,
+                System.currentTimeMillis());
+
+        // The PendingIntent to launch our activity if the user selects this notification
+        PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
+                new Intent(this, AlarmService.class), 0);
+
+        // Set the info for the views that show in the notification panel.
+        notification.setLatestEventInfo(this, getText(R.string.alarm_service_label),
+                       text, contentIntent);
+
+        // Send the notification.
+        // We use a layout id because it is a unique number.  We use it later to cancel.
+        mNM.notify(R.string.alarm_service_started, notification);
+    }
+
+    /**
+     * This is the object that receives interactions from clients.  See RemoteService
+     * for a more complete example.
+     */
+    private final IBinder mBinder = new Binder() {
+        @Override
+		protected boolean onTransact(int code, Parcel data, Parcel reply,
+		        int flags) throws RemoteException {
+            return super.onTransact(code, data, reply, flags);
+        }
+    };
+}
+