gametel 0.1

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

@@ -0,0 +1,61 @@
+/*
+ * 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.content.Intent;
+import android.os.Bundle;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+
+/**
+ * Controller to start and stop a service. The serivce will update a status bar
+ * notification every 5 seconds for a minute.
+ */
+public class NotifyingController extends Activity {
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        setContentView(R.layout.notifying_controller);
+
+        Button button = (Button) findViewById(R.id.notifyStart);
+        button.setOnClickListener(mStartListener);
+        button = (Button) findViewById(R.id.notifyStop);
+        button.setOnClickListener(mStopListener);
+    }
+
+    private OnClickListener mStartListener = new OnClickListener() {
+        public void onClick(View v) {
+            startService(new Intent(NotifyingController.this, 
+                    NotifyingService.class));
+        }
+    };
+
+    private OnClickListener mStopListener = new OnClickListener() {
+        public void onClick(View v) {
+            stopService(new Intent(NotifyingController.this, 
+                    NotifyingService.class));
+        }
+    };
+}
+

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

@@ -0,0 +1,128 @@
+/*
+ * 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.ConditionVariable;
+import android.os.IBinder;
+import android.os.Parcel;
+import android.os.RemoteException;
+
+/**
+ * This is an example of service that will update its status bar balloon 
+ * every 5 seconds for a minute.
+ * 
+ */
+public class NotifyingService extends Service {
+    
+    // Use a layout id for a unique identifier
+    private static int MOOD_NOTIFICATIONS = R.layout.status_bar_notifications;
+
+    // variable which controls the notification thread 
+    private ConditionVariable mCondition;
+ 
+    @Override
+    public void onCreate() {
+        mNM = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
+
+        // 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 notifyingThread = new Thread(null, mTask, "NotifyingService");
+        mCondition = new ConditionVariable(false);
+        notifyingThread.start();
+    }
+
+    @Override
+    public void onDestroy() {
+        // Cancel the persistent notification.
+        mNM.cancel(MOOD_NOTIFICATIONS);
+        // Stop the thread from generating further notifications
+        mCondition.open();
+    }
+
+    private Runnable mTask = new Runnable() {
+        public void run() {
+            for (int i = 0; i < 4; ++i) {
+                showNotification(R.drawable.stat_happy,
+                        R.string.status_bar_notifications_happy_message);
+                if (mCondition.block(5 * 1000)) 
+                    break;
+                showNotification(R.drawable.stat_neutral,
+                        R.string.status_bar_notifications_ok_message);
+                if (mCondition.block(5 * 1000)) 
+                    break;
+                showNotification(R.drawable.stat_sad,
+                        R.string.status_bar_notifications_sad_message);
+                if (mCondition.block(5 * 1000)) 
+                    break;
+            }
+            // Done with our work...  stop the service!
+            NotifyingService.this.stopSelf();
+        }
+    };
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return mBinder;
+    }
+    
+    private void showNotification(int moodId, int textId) {
+        // In this sample, we'll use the same text for the ticker and the expanded notification
+        CharSequence text = getText(textId);
+
+        // Set the icon, scrolling text and timestamp.
+        // Note that in this example, we pass null for tickerText.  We update the icon enough that
+        // it is distracting to show the ticker text every time it changes.  We strongly suggest
+        // that you do this as well.  (Think of of the "New hardware found" or "Network connection
+        // changed" messages that always pop up)
+        Notification notification = new Notification(moodId, null, System.currentTimeMillis());
+
+        // The PendingIntent to launch our activity if the user selects this notification
+        PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
+                new Intent(this, NotifyingController.class), 0);
+
+        // Set the info for the views that show in the notification panel.
+        notification.setLatestEventInfo(this, getText(R.string.status_bar_notifications_mood_title),
+                       text, contentIntent);
+
+        // Send the notification.
+        // We use a layout id because it is a unique number.  We use it later to cancel.
+        mNM.notify(MOOD_NOTIFICATIONS, 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);
+        }
+    };
+
+    private NotificationManager mNM;
+}

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

@@ -0,0 +1,42 @@
+/*
+ * 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;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.BroadcastReceiver;
+import android.widget.Toast;
+
+// 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;
+
+/**
+ * This is an example of implement an {@link BroadcastReceiver} for an alarm that
+ * should occur once.
+ * <p>
+ * When the alarm goes off, we show a <i>Toast</i>, a quick message.
+ */
+public class OneShotAlarm extends BroadcastReceiver
+{
+    @Override
+    public void onReceive(Context context, Intent intent)
+    {
+        Toast.makeText(context, R.string.one_shot_received, Toast.LENGTH_SHORT).show();
+    }
+}
+

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

@@ -0,0 +1,128 @@
+/*
+ * 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.content.SharedPreferences;
+import android.os.Bundle;
+import android.widget.EditText;
+import android.widget.TextView;
+
+/**
+ * Simple example of using persistent preferences to retain a screen's state.
+ * <p>This can be used as an alternative to the normal
+ * <code>onSaveInstanceState()</code> mechanism, if you
+ * wish the state to persist even after an activity is finished.</p>
+ *
+ * <p>Note that using this approach requires more care, since you are sharing
+ * the persistent state potentially across multiple instances of the activity.
+ * In particular, if you allow a new instance of the activity to be launched
+ * directly on top of the existing instance, the state can get out of sync
+ * because the new instance is resumed before the old one is paused.</p>
+ *
+ * <p>For any persistent state that is not simplistic, a content
+ * provider is often a better choice.</p>
+ *
+ * <p>In this example we are currently saving and restoring the state of the
+ * top text editor, but not of the bottom text editor.  You can see the difference
+ * by editing the two text fields, then going back from the activity and
+ * starting it again.</p>
+ *
+ * <h4>Demo</h4>
+ * App/Activity/Save &amp; Restore State
+ *
+ * <h4>Source files</h4>
+ * <table class="LinkTable">
+ *         <tr>
+ *             <td class="LinkColumn">src/com.example.android.apis/app/PersistentState.java</td>
+ *             <td class="DescrColumn">The Save/Restore Screen implementation</td>
+ *         </tr>
+ *         <tr>
+ *             <td class="LinkColumn">/res/any/layout/save_restore_state.xml</td>
+ *             <td class="DescrColumn">Defines contents of the screen</td>
+ *         </tr>
+ * </table>
+ *
+ */
+public class PersistentState extends Activity
+{
+    /**
+     * Initialization of the Activity after it is first created.  Here we use
+     * {@link android.app.Activity#setContentView setContentView()} to set up
+     * the Activity's content, and retrieve the EditText widget whose state we
+     * will persistent.
+     */
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        // Be sure to call the super class.
+        super.onCreate(savedInstanceState);
+
+        // See assets/res/any/layout/save_restore_state.xml for this
+        // view layout definition, which is being set here as
+        // the content of our screen.
+        setContentView(R.layout.save_restore_state);
+
+        // Set message to be appropriate for this screen.
+        ((TextView)findViewById(R.id.msg)).setText(R.string.persistent_msg);
+
+        // Retrieve the EditText widget whose state we will save.
+        mSaved = (EditText)findViewById(R.id.saved);
+    }
+
+    /**
+     * Upon being resumed we can retrieve the current state.  This allows us
+     * to update the state if it was changed at any time while paused.
+     */
+    @Override
+    protected void onResume() {
+        super.onResume();
+
+        SharedPreferences prefs = getPreferences(0); 
+        String restoredText = prefs.getString("text", null);
+        if (restoredText != null) {
+            mSaved.setText(restoredText, TextView.BufferType.EDITABLE);
+
+            int selectionStart = prefs.getInt("selection-start", -1);
+            int selectionEnd = prefs.getInt("selection-end", -1);
+            if (selectionStart != -1 && selectionEnd != -1) {
+                mSaved.setSelection(selectionStart, selectionEnd);
+            }
+        }
+    }
+
+    /**
+     * Any time we are paused we need to save away the current state, so it
+     * will be restored correctly when we are resumed.
+     */
+    @Override
+    protected void onPause() {
+        super.onPause();
+
+        SharedPreferences.Editor editor = getPreferences(0).edit();
+        editor.putString("text", mSaved.getText().toString());
+        editor.putInt("selection-start", mSaved.getSelectionStart());
+        editor.putInt("selection-end", mSaved.getSelectionEnd());
+        editor.commit();
+    }
+
+    private EditText mSaved;
+}

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

@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2009 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 android.app.ListActivity;
+import android.content.Context;
+import android.database.CharArrayBuffer;
+import android.database.Cursor;
+import android.os.Bundle;
+import android.provider.ContactsContract.Contacts;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.QuickContactBadge;
+import android.widget.ResourceCursorAdapter;
+import android.widget.TextView;
+
+public class QuickContactsDemo extends ListActivity {
+    static final String[] CONTACTS_SUMMARY_PROJECTION = new String[] {
+            Contacts._ID, // 0
+            Contacts.DISPLAY_NAME, // 1
+            Contacts.STARRED, // 2
+            Contacts.TIMES_CONTACTED, // 3
+            Contacts.CONTACT_PRESENCE, // 4
+            Contacts.PHOTO_ID, // 5
+            Contacts.LOOKUP_KEY, // 6
+            Contacts.HAS_PHONE_NUMBER, // 7
+    };
+
+    static final int SUMMARY_ID_COLUMN_INDEX = 0;
+    static final int SUMMARY_NAME_COLUMN_INDEX = 1;
+    static final int SUMMARY_STARRED_COLUMN_INDEX = 2;
+    static final int SUMMARY_TIMES_CONTACTED_COLUMN_INDEX = 3;
+    static final int SUMMARY_PRESENCE_STATUS_COLUMN_INDEX = 4;
+    static final int SUMMARY_PHOTO_ID_COLUMN_INDEX = 5;
+    static final int SUMMARY_LOOKUP_KEY = 6;
+    static final int SUMMARY_HAS_PHONE_COLUMN_INDEX = 7;
+
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        String select = "((" + Contacts.DISPLAY_NAME + " NOTNULL) AND ("
+                + Contacts.HAS_PHONE_NUMBER + "=1) AND ("
+                + Contacts.DISPLAY_NAME + " != '' ))";
+        Cursor c =
+                getContentResolver().query(Contacts.CONTENT_URI, CONTACTS_SUMMARY_PROJECTION, select,
+                null, Contacts.DISPLAY_NAME + " COLLATE LOCALIZED ASC");
+        startManagingCursor(c);
+        ContactListItemAdapter adapter = new ContactListItemAdapter(this, R.layout.quick_contacts, c);
+        setListAdapter(adapter);
+
+    }
+
+    private final class ContactListItemAdapter extends ResourceCursorAdapter {
+        public ContactListItemAdapter(Context context, int layout, Cursor c) {
+            super(context, layout, c);
+        }
+
+        @Override
+        public void bindView(View view, Context context, Cursor cursor) {
+            final ContactListItemCache cache = (ContactListItemCache) view.getTag();
+            // Set the name
+            cursor.copyStringToBuffer(SUMMARY_NAME_COLUMN_INDEX, cache.nameBuffer);
+            int size = cache.nameBuffer.sizeCopied;
+            cache.nameView.setText(cache.nameBuffer.data, 0, size);
+            final long contactId = cursor.getLong(SUMMARY_ID_COLUMN_INDEX);
+            final String lookupKey = cursor.getString(SUMMARY_LOOKUP_KEY);
+            cache.photoView.assignContactUri(Contacts.getLookupUri(contactId, lookupKey));
+        }
+
+        @Override
+        public View newView(Context context, Cursor cursor, ViewGroup parent) {
+            View view = super.newView(context, cursor, parent);
+            ContactListItemCache cache = new ContactListItemCache();
+            cache.nameView = (TextView) view.findViewById(R.id.name);
+            cache.photoView = (QuickContactBadge) view.findViewById(R.id.badge);
+            view.setTag(cache);
+
+            return view;
+        }
+    }
+
+    final static class ContactListItemCache {
+        public TextView nameView;
+        public QuickContactBadge photoView;
+        public CharArrayBuffer nameBuffer = new CharArrayBuffer(128);
+    }
+}