gametel 0.1

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

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2012 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.Activity;
+import android.app.NotificationManager;
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.View;
+import android.widget.Button;
+
+/**
+ * This is an activity that provides an interstitial UI for the notification
+ * that is posted by {@link IncomingMessage}.  It allows the user to switch
+ * to the app in its appropriate state if they want.
+ */
+public class IncomingMessageInterstitial extends Activity {
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        setContentView(R.layout.incoming_message_interstitial);
+
+        Button button = (Button) findViewById(R.id.notify_app);
+        button.setOnClickListener(new Button.OnClickListener() {
+                public void onClick(View v) {
+                    switchToApp();
+                }
+            });
+    }
+
+
+    /**
+     * Perform a switch to the app.  A new activity stack is started, replacing
+     * whatever is currently running, and this activity is finished.
+     */
+    void switchToApp() {
+        // We will launch the app showing what the user picked.  In this simple
+        // example, it is just what the notification gave us.
+        CharSequence from = getIntent().getCharSequenceExtra(IncomingMessageView.KEY_FROM);
+        CharSequence msg = getIntent().getCharSequenceExtra(IncomingMessageView.KEY_MESSAGE);
+        // Build the new activity stack, launch it, and finish this UI.
+        Intent[] stack = IncomingMessage.makeMessageIntentStack(this, from, msg);
+        startActivities(stack);
+        finish();
+    }
+
+}

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

@@ -0,0 +1,59 @@
+/*
+ * 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 com.example.android.apis.R;
+
+import android.app.Activity;
+import android.app.NotificationManager;
+import android.os.Bundle;
+import android.widget.TextView;
+
+/**
+ * This activity is run as the click activity for {@link IncomingMessage}.
+ * When it comes up, it also clears the notification, because the "message"
+ * has been "read."
+ */
+public class IncomingMessageView extends Activity {
+    /**
+     * Extra that can be supplied to Intent: who the message is from.
+     */
+    static final public String KEY_FROM = "from";
+    /**
+     * Extra that can be supplied to Intent: the message that was sent.
+     */
+    static final public String KEY_MESSAGE = "message";
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.incoming_message_view);
+
+        // Fill in the message content.
+        ((TextView)findViewById(R.id.from)).setText(
+                getIntent().getCharSequenceExtra(KEY_FROM));
+        ((TextView)findViewById(R.id.message)).setText(
+                getIntent().getCharSequenceExtra(KEY_MESSAGE));
+
+        // look up the notification manager service
+        NotificationManager nm = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
+
+        // cancel the notification that we started in IncomingMessage
+        nm.cancel(R.string.imcoming_message_ticker_text);
+    }
+}
+

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

@@ -0,0 +1,86 @@
+package com.example.android.apis.app;
+
+import com.example.android.apis.R;
+
+import android.app.Activity;
+import android.app.PendingIntent;
+import android.app.PendingIntent.CanceledException;
+import android.content.ComponentName;
+import android.content.Context;
+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;
+
+/**
+ * Example of various Intent flags to modify the activity stack.
+ */
+public class IntentActivityFlags extends Activity {
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        setContentView(R.layout.intent_activity_flags);
+
+        // Watch for button clicks.
+        Button button = (Button)findViewById(R.id.flag_activity_clear_task);
+        button.setOnClickListener(mFlagActivityClearTaskListener);
+        button = (Button)findViewById(R.id.flag_activity_clear_task_pi);
+        button.setOnClickListener(mFlagActivityClearTaskPIListener);
+    }
+
+    /**
+     * This creates an array of Intent objects representing the back stack
+     * for a user going into the Views/Lists API demos.
+     */
+
+    private Intent[] buildIntentsToViewsLists() {
+        // We are going to rebuild our task with a new back stack.  This will
+        // be done by launching an array of Intents, representing the new
+        // back stack to be created, with the first entry holding the root
+        // and requesting to reset the back stack.
+        Intent[] intents = new Intent[3];
+
+        // First: root activity of ApiDemos.
+        // This is a convenient way to make the proper Intent to launch and
+        // reset an application's task.
+        intents[0] = Intent.makeRestartActivityTask(new ComponentName(this,
+                com.example.android.apis.ApiDemos.class));
+
+        Intent intent = new Intent(Intent.ACTION_MAIN);
+        intent.setClass(IntentActivityFlags.this, com.example.android.apis.ApiDemos.class);
+        intent.putExtra("com.example.android.apis.Path", "Views");
+        intents[1] = intent;
+
+        intent = new Intent(Intent.ACTION_MAIN);
+        intent.setClass(IntentActivityFlags.this, com.example.android.apis.ApiDemos.class);
+        intent.putExtra("com.example.android.apis.Path", "Views/Lists");
+
+        intents[2] = intent;
+        return intents;
+    }
+
+
+    private OnClickListener mFlagActivityClearTaskListener = new OnClickListener() {
+        public void onClick(View v) {
+            startActivities(buildIntentsToViewsLists());
+        }
+    };
+
+    private OnClickListener mFlagActivityClearTaskPIListener = new OnClickListener() {
+        public void onClick(View v) {
+            Context context = IntentActivityFlags.this;
+
+            PendingIntent pi = PendingIntent.getActivities(context, 0,
+                    buildIntentsToViewsLists(), PendingIntent.FLAG_UPDATE_CURRENT);
+
+            try {
+                pi.send();
+            } catch (CanceledException e) {
+                Log.w("IntentActivityFlags", "Failed sending PendingIntent", e);
+            }
+        }
+    };
+}

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

@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2008 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.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+
+public class Intents extends Activity {
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        setContentView(R.layout.intents);
+
+        // Watch for button clicks.
+        Button button = (Button)findViewById(R.id.get_music);
+        button.setOnClickListener(mGetMusicListener);
+    }
+
+    private OnClickListener mGetMusicListener = new OnClickListener() {
+        public void onClick(View v) {
+            Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
+            intent.setType("audio/*");
+            startActivity(Intent.createChooser(intent, "Select music"));
+        }
+    };
+}

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

@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2008 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.content.Intent;
+import android.os.Bundle;
+import android.os.Parcelable;
+import android.widget.TextView;
+
+import com.example.android.apis.R;
+
+/**
+ * This Activity actually handles two stages of a launcher shortcut's life cycle.
+ * 
+ * 1. Your application offers to provide shortcuts to the launcher.  When
+ *    the user installs a shortcut, an activity within your application
+ *    generates the actual shortcut and returns it to the launcher, where it
+ *    is shown to the user as an icon.
+ *
+ * 2. Any time the user clicks on an installed shortcut, an intent is sent.
+ *    Typically this would then be handled as necessary by an activity within
+ *    your application.
+ *    
+ * We handle stage 1 (creating a shortcut) by simply sending back the information (in the form
+ * of an {@link android.content.Intent} that the launcher will use to create the shortcut.
+ * 
+ * You can also implement this in an interactive way, by having your activity actually present
+ * UI for the user to select the specific nature of the shortcut, such as a contact, picture, URL,
+ * media item, or action.
+ * 
+ * We handle stage 2 (responding to a shortcut) in this sample by simply displaying the contents
+ * of the incoming {@link android.content.Intent}.
+ * 
+ * In a real application, you would probably use the shortcut intent to display specific content
+ * or start a particular operation.
+ */
+public class LauncherShortcuts extends Activity {
+
+    private static final String EXTRA_KEY = "com.example.android.apis.app.LauncherShortcuts";
+
+    @Override
+    public void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+
+        // Resolve the intent
+
+        final Intent intent = getIntent();
+        final String action = intent.getAction();
+
+        // If the intent is a request to create a shortcut, we'll do that and exit
+
+        if (Intent.ACTION_CREATE_SHORTCUT.equals(action)) {
+            setupShortcut();
+            finish();
+            return;
+        }
+
+        // If we weren't launched with a CREATE_SHORTCUT intent, simply put up an informative
+        // display.
+
+        // Inflate our UI from its XML layout description.
+
+        setContentView(R.layout.launcher_shortcuts);
+
+        // Provide a lightweight view of the Intent that launched us
+
+        TextView intentInfo = (TextView) findViewById(R.id.txt_shortcut_intent);
+        String info = intent.toString();
+        String extra = intent.getStringExtra(EXTRA_KEY);
+        if (extra != null) {
+            info = info + " " + extra;
+        }
+        intentInfo.setText(info);
+    }
+
+    /**
+     * This function creates a shortcut and returns it to the caller.  There are actually two 
+     * intents that you will send back.
+     * 
+     * The first intent serves as a container for the shortcut and is returned to the launcher by 
+     * setResult().  This intent must contain three fields:
+     * 
+     * <ul>
+     * <li>{@link android.content.Intent#EXTRA_SHORTCUT_INTENT} The shortcut intent.</li>
+     * <li>{@link android.content.Intent#EXTRA_SHORTCUT_NAME} The text that will be displayed with
+     * the shortcut.</li>
+     * <li>{@link android.content.Intent#EXTRA_SHORTCUT_ICON} The shortcut's icon, if provided as a
+     * bitmap, <i>or</i> {@link android.content.Intent#EXTRA_SHORTCUT_ICON_RESOURCE} if provided as
+     * a drawable resource.</li>
+     * </ul>
+     * 
+     * If you use a simple drawable resource, note that you must wrapper it using
+     * {@link android.content.Intent.ShortcutIconResource}, as shown below.  This is required so
+     * that the launcher can access resources that are stored in your application's .apk file.  If 
+     * you return a bitmap, such as a thumbnail, you can simply put the bitmap into the extras 
+     * bundle using {@link android.content.Intent#EXTRA_SHORTCUT_ICON}.
+     * 
+     * The shortcut intent can be any intent that you wish the launcher to send, when the user 
+     * clicks on the shortcut.  Typically this will be {@link android.content.Intent#ACTION_VIEW} 
+     * with an appropriate Uri for your content, but any Intent will work here as long as it 
+     * triggers the desired action within your Activity.
+     */
+    private void setupShortcut() {
+        // First, set up the shortcut intent.  For this example, we simply create an intent that
+        // will bring us directly back to this activity.  A more typical implementation would use a 
+        // data Uri in order to display a more specific result, or a custom action in order to 
+        // launch a specific operation.
+
+        Intent shortcutIntent = new Intent(Intent.ACTION_MAIN);
+        shortcutIntent.setClassName(this, this.getClass().getName());
+        shortcutIntent.putExtra(EXTRA_KEY, "ApiDemos Provided This Shortcut");
+
+        // Then, set up the container intent (the response to the caller)
+
+        Intent intent = new Intent();
+        intent.putExtra(Intent.EXTRA_SHORTCUT_INTENT, shortcutIntent);
+        intent.putExtra(Intent.EXTRA_SHORTCUT_NAME, getString(R.string.shortcut_name));
+        Parcelable iconResource = Intent.ShortcutIconResource.fromContext(
+                this,  R.drawable.app_sample_code);
+        intent.putExtra(Intent.EXTRA_SHORTCUT_ICON_RESOURCE, iconResource);
+
+        // Now, return the result to the launcher
+
+        setResult(RESULT_OK, intent);
+    }
+}

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

@@ -0,0 +1,177 @@
+/*
+ * 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.app.FragmentManager;
+import android.app.ListFragment;
+import android.app.LoaderManager;
+import android.content.CursorLoader;
+import android.content.Loader;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.Bundle;
+import android.provider.ContactsContract.Contacts;
+import android.text.TextUtils;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.ListView;
+import android.widget.SearchView;
+import android.widget.SimpleCursorAdapter;
+import android.widget.SearchView.OnQueryTextListener;
+
+/**
+ * Demonstration of the use of a CursorLoader to load and display contacts
+ * data in a fragment.
+ */
+public class LoaderCursor extends Activity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        FragmentManager fm = getFragmentManager();
+
+        // Create the list fragment and add it as our sole content.
+        if (fm.findFragmentById(android.R.id.content) == null) {
+            CursorLoaderListFragment list = new CursorLoaderListFragment();
+            fm.beginTransaction().add(android.R.id.content, list).commit();
+        }
+    }
+
+
+    public static class CursorLoaderListFragment extends ListFragment
+            implements OnQueryTextListener, LoaderManager.LoaderCallbacks<Cursor> {
+
+        // This is the Adapter being used to display the list's data.
+        SimpleCursorAdapter mAdapter;
+
+        // If non-null, this is the current filter the user has provided.
+        String mCurFilter;
+
+        @Override public void onActivityCreated(Bundle savedInstanceState) {
+            super.onActivityCreated(savedInstanceState);
+
+            // Give some text to display if there is no data.  In a real
+            // application this would come from a resource.
+            setEmptyText("No phone numbers");
+
+            // We have a menu item to show in action bar.
+            setHasOptionsMenu(true);
+
+            // Create an empty adapter we will use to display the loaded data.
+            mAdapter = new SimpleCursorAdapter(getActivity(),
+                    android.R.layout.simple_list_item_2, null,
+                    new String[] { Contacts.DISPLAY_NAME, Contacts.CONTACT_STATUS },
+                    new int[] { android.R.id.text1, android.R.id.text2 }, 0);
+            setListAdapter(mAdapter);
+
+            // Start out with a progress indicator.
+            setListShown(false);
+
+            // Prepare the loader.  Either re-connect with an existing one,
+            // or start a new one.
+            getLoaderManager().initLoader(0, null, this);
+        }
+
+        @Override public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+            // Place an action bar item for searching.
+            MenuItem item = menu.add("Search");
+            item.setIcon(android.R.drawable.ic_menu_search);
+            item.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
+            SearchView sv = new SearchView(getActivity());
+            sv.setOnQueryTextListener(this);
+            item.setActionView(sv);
+        }
+
+        public boolean onQueryTextChange(String newText) {
+            // Called when the action bar search text has changed.  Update
+            // the search filter, and restart the loader to do a new query
+            // with this filter.
+            mCurFilter = !TextUtils.isEmpty(newText) ? newText : null;
+            getLoaderManager().restartLoader(0, null, this);
+            return true;
+        }
+
+        @Override public boolean onQueryTextSubmit(String query) {
+            // Don't care about this.
+            return true;
+        }
+
+        @Override public void onListItemClick(ListView l, View v, int position, long id) {
+            // Insert desired behavior here.
+            Log.i("FragmentComplexList", "Item clicked: " + id);
+        }
+
+        // These are the Contacts rows that we will retrieve.
+        static final String[] CONTACTS_SUMMARY_PROJECTION = new String[] {
+            Contacts._ID,
+            Contacts.DISPLAY_NAME,
+            Contacts.CONTACT_STATUS,
+            Contacts.CONTACT_PRESENCE,
+            Contacts.PHOTO_ID,
+            Contacts.LOOKUP_KEY,
+        };
+
+        public Loader<Cursor> onCreateLoader(int id, Bundle args) {
+            // This is called when a new Loader needs to be created.  This
+            // sample only has one Loader, so we don't care about the ID.
+            // First, pick the base URI to use depending on whether we are
+            // currently filtering.
+            Uri baseUri;
+            if (mCurFilter != null) {
+                baseUri = Uri.withAppendedPath(Contacts.CONTENT_FILTER_URI,
+                        Uri.encode(mCurFilter));
+            } else {
+                baseUri = Contacts.CONTENT_URI;
+            }
+
+            // Now create and return a CursorLoader that will take care of
+            // creating a Cursor for the data being displayed.
+            String select = "((" + Contacts.DISPLAY_NAME + " NOTNULL) AND ("
+                    + Contacts.HAS_PHONE_NUMBER + "=1) AND ("
+                    + Contacts.DISPLAY_NAME + " != '' ))";
+            return new CursorLoader(getActivity(), baseUri,
+                    CONTACTS_SUMMARY_PROJECTION, select, null,
+                    Contacts.DISPLAY_NAME + " COLLATE LOCALIZED ASC");
+        }
+
+        public void onLoadFinished(Loader<Cursor> loader, Cursor data) {
+            // Swap the new cursor in.  (The framework will take care of closing the
+            // old cursor once we return.)
+            mAdapter.swapCursor(data);
+
+            // The list should now be shown.
+            if (isResumed()) {
+                setListShown(true);
+            } else {
+                setListShownNoAnimation(true);
+            }
+        }
+
+        public void onLoaderReset(Loader<Cursor> loader) {
+            // This is called when the last Cursor provided to onLoadFinished()
+            // above is about to be closed.  We need to make sure we are no
+            // longer using it.
+            mAdapter.swapCursor(null);
+        }
+    }
+
+}