gametel 0.1

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

@@ -0,0 +1,124 @@
+/*
+ * 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 android.app.Activity;
+import android.app.Fragment;
+import android.app.FragmentTransaction;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.TextView;
+
+public class FragmentStack extends Activity {
+    int mStackLevel = 1;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.fragment_stack);
+        
+        // Watch for button clicks.
+        Button button = (Button)findViewById(R.id.new_fragment);
+        button.setOnClickListener(new OnClickListener() {
+            public void onClick(View v) {
+                addFragmentToStack();
+            }
+        });
+
+        if (savedInstanceState == null) {
+            // Do first time initialization -- add initial fragment.
+            Fragment newFragment = CountingFragment.newInstance(mStackLevel);
+            FragmentTransaction ft = getFragmentManager().beginTransaction();
+            ft.add(R.id.simple_fragment, newFragment).commit();
+        } else {
+            mStackLevel = savedInstanceState.getInt("level");
+        }
+    }
+
+    @Override
+    public void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+        outState.putInt("level", mStackLevel);
+    }
+
+
+    void addFragmentToStack() {
+        mStackLevel++;
+
+        // Instantiate a new fragment.
+        Fragment newFragment = CountingFragment.newInstance(mStackLevel);
+
+        // Add the fragment to the activity, pushing this transaction
+        // on to the back stack.
+        FragmentTransaction ft = getFragmentManager().beginTransaction();
+        ft.replace(R.id.simple_fragment, newFragment);
+        ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN);
+        ft.addToBackStack(null);
+        ft.commit();
+    }
+
+
+
+    public static class CountingFragment extends Fragment {
+        int mNum;
+
+        /**
+         * Create a new instance of CountingFragment, providing "num"
+         * as an argument.
+         */
+        static CountingFragment newInstance(int num) {
+            CountingFragment f = new CountingFragment();
+
+            // Supply num input as an argument.
+            Bundle args = new Bundle();
+            args.putInt("num", num);
+            f.setArguments(args);
+
+            return f;
+        }
+
+        /**
+         * When creating, retrieve this instance's number from its arguments.
+         */
+        @Override
+        public void onCreate(Bundle savedInstanceState) {
+            super.onCreate(savedInstanceState);
+            mNum = getArguments() != null ? getArguments().getInt("num") : 1;
+        }
+
+        /**
+         * The Fragment's UI is just a simple text view showing its
+         * instance number.
+         */
+        @Override
+        public View onCreateView(LayoutInflater inflater, ViewGroup container,
+                Bundle savedInstanceState) {
+            View v = inflater.inflate(R.layout.hello_world, container, false);
+            View tv = v.findViewById(R.id.text);
+            ((TextView)tv).setText("Fragment #" + mNum);
+            tv.setBackgroundDrawable(getResources().getDrawable(android.R.drawable.gallery_thumb));
+            return v;
+        }
+    }
+
+}

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

@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2011 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.ActionBar;
+import android.app.ActionBar.Tab;
+import android.app.Activity;
+import android.app.Fragment;
+import android.app.FragmentTransaction;
+import android.os.Bundle;
+import android.widget.Toast;
+
+/**
+ * This demonstrates the use of action bar tabs and how they interact
+ * with other action bar features.
+ */
+public class FragmentTabs extends Activity {
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        final ActionBar bar = getActionBar();
+        bar.setNavigationMode(ActionBar.NAVIGATION_MODE_TABS);
+        bar.setDisplayOptions(0, ActionBar.DISPLAY_SHOW_TITLE);
+
+        bar.addTab(bar.newTab()
+                .setText("Simple")
+                .setTabListener(new TabListener<FragmentStack.CountingFragment>(
+                        this, "simple", FragmentStack.CountingFragment.class)));
+        bar.addTab(bar.newTab()
+                .setText("Contacts")
+                .setTabListener(new TabListener<LoaderCursor.CursorLoaderListFragment>(
+                        this, "contacts", LoaderCursor.CursorLoaderListFragment.class)));
+        bar.addTab(bar.newTab()
+                .setText("Apps")
+                .setTabListener(new TabListener<LoaderCustom.AppListFragment>(
+                        this, "apps", LoaderCustom.AppListFragment.class)));
+        bar.addTab(bar.newTab()
+                .setText("Throttle")
+                .setTabListener(new TabListener<LoaderThrottle.ThrottledLoaderListFragment>(
+                        this, "throttle", LoaderThrottle.ThrottledLoaderListFragment.class)));
+
+        if (savedInstanceState != null) {
+            bar.setSelectedNavigationItem(savedInstanceState.getInt("tab", 0));
+        }
+    }
+
+    @Override
+    protected void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+        outState.putInt("tab", getActionBar().getSelectedNavigationIndex());
+    }
+
+    public static class TabListener<T extends Fragment> implements ActionBar.TabListener {
+        private final Activity mActivity;
+        private final String mTag;
+        private final Class<T> mClass;
+        private final Bundle mArgs;
+        private Fragment mFragment;
+
+        public TabListener(Activity activity, String tag, Class<T> clz) {
+            this(activity, tag, clz, null);
+        }
+
+        public TabListener(Activity activity, String tag, Class<T> clz, Bundle args) {
+            mActivity = activity;
+            mTag = tag;
+            mClass = clz;
+            mArgs = args;
+
+            // Check to see if we already have a fragment for this tab, probably
+            // from a previously saved state.  If so, deactivate it, because our
+            // initial state is that a tab isn't shown.
+            mFragment = mActivity.getFragmentManager().findFragmentByTag(mTag);
+            if (mFragment != null && !mFragment.isDetached()) {
+                FragmentTransaction ft = mActivity.getFragmentManager().beginTransaction();
+                ft.detach(mFragment);
+                ft.commit();
+            }
+        }
+
+        public void onTabSelected(Tab tab, FragmentTransaction ft) {
+            if (mFragment == null) {
+                mFragment = Fragment.instantiate(mActivity, mClass.getName(), mArgs);
+                ft.add(android.R.id.content, mFragment, mTag);
+            } else {
+                ft.attach(mFragment);
+            }
+        }
+
+        public void onTabUnselected(Tab tab, FragmentTransaction ft) {
+            if (mFragment != null) {
+                ft.detach(mFragment);
+            }
+        }
+
+        public void onTabReselected(Tab tab, FragmentTransaction ft) {
+            Toast.makeText(mActivity, "Reselected!", Toast.LENGTH_SHORT).show();
+        }
+    }
+}
+

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

@@ -0,0 +1,66 @@
+/*
+ * 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.os.Bundle;
+
+
+/**
+ * Simple example of writing an application Activity.
+ * Hello World</a></h3>
+
+<p>This demonstrates the basic code needed to write a Screen activity.</p>
+
+<h4>Demo</h4>
+App/Activity/Hello World
+ 
+<h4>Source files</h4>
+ * <table class="LinkTable">
+ *         <tr>
+ *             <td >src/com.example.android.apis/app/HelloWorld.java</td>
+ *             <td >The Hello World Screen implementation</td>
+ *         </tr>
+ *         <tr>
+ *             <td >/res/any/layout/hello_world.xml</td>
+ *             <td >Defines contents of the screen</td>
+ *         </tr>
+ * </table> 
+ */
+public class HelloWorld extends Activity
+{
+    /**
+     * Initialization of the Activity after it is first created.  Must at least
+     * call {@link android.app.Activity#setContentView setContentView()} to
+     * describe what is to be displayed in the screen.
+     */
+    @Override
+	protected void onCreate(Bundle savedInstanceState)
+    {
+        // Be sure to call the super class.
+        super.onCreate(savedInstanceState);
+
+        // See assets/res/any/layout/hello_world.xml for this
+        // view layout definition, which is being set here as
+        // the content of our screen.
+        setContentView(R.layout.hello_world);
+    }
+}

data/ApiDemos/src/com/example/android/apis/app/IRemoteService.aidl

@@ -0,0 +1,37 @@
+/*
+ * 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.app.IRemoteServiceCallback;
+
+/**
+ * Example of defining an interface for calling on to a remote service
+ * (running in another process).
+ */
+interface IRemoteService {
+    /**
+     * Often you want to allow a service to call back to its clients.
+     * This shows how to do so, by registering a callback interface with
+     * the service.
+     */
+    void registerCallback(IRemoteServiceCallback cb);
+    
+    /**
+     * Remove a previously registered callback interface.
+     */
+    void unregisterCallback(IRemoteServiceCallback cb);
+}

data/ApiDemos/src/com/example/android/apis/app/IRemoteServiceCallback.aidl

@@ -0,0 +1,29 @@
+/*
+ * 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;
+
+/**
+ * Example of a callback interface used by IRemoteService to send
+ * synchronous notifications back to its clients.  Note that this is a
+ * one-way interface so the server does not block waiting for the client.
+ */
+oneway interface IRemoteServiceCallback {
+    /**
+     * Called when the service has a new value for you.
+     */
+    void valueChanged(int value);
+}

data/ApiDemos/src/com/example/android/apis/app/ISecondary.aidl

@@ -0,0 +1,36 @@
+/*
+ * 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;
+
+/**
+ * Example of a secondary interface associated with a service.  (Note that
+ * the interface itself doesn't impact, it is just a matter of how you
+ * retrieve it from the service.)
+ */
+interface ISecondary {
+    /**
+     * Request the PID of this service, to do evil things with it.
+     */
+    int getPid();
+    
+    /**
+     * This demonstrates the basic types that you can use as parameters
+     * and return values in AIDL.
+     */
+    void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
+            double aDouble, String aString);
+}

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

@@ -0,0 +1,197 @@
+/*
+ * 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 java.util.Random;
+
+import com.example.android.apis.R;
+
+import android.app.Activity;
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.View;
+import android.widget.Button;
+
+/**
+ * UI for posting an example notification.
+ */
+public class IncomingMessage extends Activity {
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        setContentView(R.layout.incoming_message);
+
+        Button button = (Button) findViewById(R.id.notify_app);
+        button.setOnClickListener(new Button.OnClickListener() {
+                public void onClick(View v) {
+                    showAppNotification();
+                }
+            });
+
+        button = (Button) findViewById(R.id.notify_interstitial);
+        button.setOnClickListener(new Button.OnClickListener() {
+                public void onClick(View v) {
+                    showInterstitialNotification();
+                }
+            });
+    }
+
+
+
+    /**
+     * This method creates an array of Intent objects representing the
+     * activity stack for the incoming message details state that the
+     * application should be in when launching it from a notification.
+     */
+    static Intent[] makeMessageIntentStack(Context context, CharSequence from,
+            CharSequence msg) {
+        // A typical convention for notifications is to launch the user deeply
+        // into an application representing the data in the notification; to
+        // accomplish this, we can build an array of intents to insert the back
+        // stack stack history above the item being displayed.
+        Intent[] intents = new Intent[4];
+
+        // 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(context,
+                com.example.android.apis.ApiDemos.class));
+
+        // "App"
+        intents[1] = new Intent(context, com.example.android.apis.ApiDemos.class);
+        intents[1].putExtra("com.example.android.apis.Path", "App");
+        // "App/Notification"
+        intents[2] = new Intent(context, com.example.android.apis.ApiDemos.class);
+        intents[2].putExtra("com.example.android.apis.Path", "App/Notification");
+
+        // Now the activity to display to the user.  Also fill in the data it
+        // should display.
+        intents[3] = new Intent(context, IncomingMessageView.class);
+        intents[3].putExtra(IncomingMessageView.KEY_FROM, from);
+        intents[3].putExtra(IncomingMessageView.KEY_MESSAGE, msg);
+
+        return intents;
+    }
+
+
+    /**
+     * The notification is the icon and associated expanded entry in the
+     * status bar.
+     */
+    void showAppNotification() {
+        // look up the notification manager service
+        NotificationManager nm = (NotificationManager)getSystemService(NOTIFICATION_SERVICE);
+
+        // The details of our fake message
+        CharSequence from = "Joe";
+        CharSequence message;
+        switch ((new Random().nextInt()) % 3) {
+            case 0: message = "r u hungry?  i am starved"; break;
+            case 1: message = "im nearby u"; break;
+            default: message = "kthx. meet u for dinner. cul8r"; break;
+        }
+
+        // The PendingIntent to launch our activity if the user selects this
+        // notification.  Note the use of FLAG_CANCEL_CURRENT so that, if there
+        // is already an active matching pending intent, cancel it and replace
+        // it with the new array of Intents.
+        PendingIntent contentIntent = PendingIntent.getActivities(this, 0,
+                makeMessageIntentStack(this, from, message), PendingIntent.FLAG_CANCEL_CURRENT);
+
+        // The ticker text, this uses a formatted string so our message could be localized
+        String tickerText = getString(R.string.imcoming_message_ticker_text, message);
+
+        // construct the Notification object.
+        Notification notif = new Notification(R.drawable.stat_sample, tickerText,
+                System.currentTimeMillis());
+
+        // Set the info for the views that show in the notification panel.
+        notif.setLatestEventInfo(this, from, message, contentIntent);
+
+        // We'll have this notification do the default sound, vibration, and led.
+        // Note that if you want any of these behaviors, you should always have
+        // a preference for the user to turn them off.
+        notif.defaults = Notification.DEFAULT_ALL;
+
+        // Note that we use R.layout.incoming_message_panel as the ID for
+        // the notification.  It could be any integer you want, but we use
+        // the convention of using a resource id for a string related to
+        // the notification.  It will always be a unique number within your
+        // application.
+        nm.notify(R.string.imcoming_message_ticker_text, notif);
+    }
+
+
+
+    /**
+     * The notification is the icon and associated expanded entry in the
+     * status bar.
+     */
+    void showInterstitialNotification() {
+        // look up the notification manager service
+        NotificationManager nm = (NotificationManager)getSystemService(NOTIFICATION_SERVICE);
+
+        // The details of our fake message
+        CharSequence from = "Dianne";
+        CharSequence message;
+        switch ((new Random().nextInt()) % 3) {
+            case 0: message = "i am ready for some dinner"; break;
+            case 1: message = "how about thai down the block?"; break;
+            default: message = "meet u soon. dont b late!"; break;
+        }
+
+        // The PendingIntent to launch our activity if the user selects this
+        // notification.  Note the use of FLAG_CANCEL_CURRENT so that, if there
+        // is already an active matching pending intent, cancel it and replace
+        // it with the new Intent.
+        Intent intent = new Intent(this, IncomingMessageInterstitial.class);
+        intent.putExtra(IncomingMessageView.KEY_FROM, from);
+        intent.putExtra(IncomingMessageView.KEY_MESSAGE, message);
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
+        PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
+                intent, PendingIntent.FLAG_CANCEL_CURRENT);
+
+        // The ticker text, this uses a formatted string so our message could be localized
+        String tickerText = getString(R.string.imcoming_message_ticker_text, message);
+
+        // construct the Notification object.
+        Notification notif = new Notification(R.drawable.stat_sample, tickerText,
+                System.currentTimeMillis());
+
+        // Set the info for the views that show in the notification panel.
+        notif.setLatestEventInfo(this, from, message, contentIntent);
+
+        // We'll have this notification do the default sound, vibration, and led.
+        // Note that if you want any of these behaviors, you should always have
+        // a preference for the user to turn them off.
+        notif.defaults = Notification.DEFAULT_ALL;
+
+        // Note that we use R.layout.incoming_message_panel as the ID for
+        // the notification.  It could be any integer you want, but we use
+        // the convention of using a resource id for a string related to
+        // the notification.  It will always be a unique number within your
+        // application.
+        nm.notify(R.string.imcoming_message_ticker_text, notif);
+    }
+
+}