gametel 0.1

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

@@ -0,0 +1,89 @@
+/*
+ * 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;
+
+// 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 java.io.IOException;
+
+import android.app.Activity;
+import android.app.WallpaperManager;
+import android.graphics.Color;
+import android.graphics.PorterDuff;
+import android.graphics.drawable.Drawable;
+import android.os.Bundle;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.ImageView;
+
+/**
+ * <h3>SetWallpaper Activity</h3>
+ *
+ * <p>This demonstrates the how to write an activity that gets the current system wallpaper,
+ * modifies it and sets the modified bitmap as system wallpaper.</p>
+ */
+public class SetWallpaperActivity extends Activity {
+    final static private int[] mColors =
+            {Color.BLUE, Color.GREEN, Color.RED, Color.LTGRAY, Color.MAGENTA, Color.CYAN,
+                    Color.YELLOW, Color.WHITE};
+
+    /**
+     * 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 res/layout/wallpaper_2.xml for this
+        // view layout definition, which is being set here as
+        // the content of our screen.
+        setContentView(R.layout.wallpaper_2);
+        final WallpaperManager wallpaperManager = WallpaperManager.getInstance(this);
+        final Drawable wallpaperDrawable = wallpaperManager.getDrawable();
+        final ImageView imageView = (ImageView) findViewById(R.id.imageview);
+        imageView.setDrawingCacheEnabled(true);
+        imageView.setImageDrawable(wallpaperDrawable);
+
+        Button randomize = (Button) findViewById(R.id.randomize);
+        randomize.setOnClickListener(new OnClickListener() {
+            public void onClick(View view) {
+                int mColor = (int) Math.floor(Math.random() * mColors.length);
+                wallpaperDrawable.setColorFilter(mColors[mColor], PorterDuff.Mode.MULTIPLY);
+                imageView.setImageDrawable(wallpaperDrawable);
+                imageView.invalidate();
+            }
+        });
+
+        Button setWallpaper = (Button) findViewById(R.id.setwallpaper);
+        setWallpaper.setOnClickListener(new OnClickListener() {
+            public void onClick(View view) {
+                try {
+                    wallpaperManager.setBitmap(imageView.getDrawingCache());
+                    finish();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+}
+

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

@@ -0,0 +1,67 @@
+package com.example.android.apis.app;
+
+import com.example.android.apis.R;
+
+import android.app.Activity;
+import android.app.admin.DevicePolicyManager;
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.view.View;
+import android.view.WindowManager;
+import android.widget.AdapterView;
+import android.widget.ArrayAdapter;
+import android.widget.EditText;
+import android.widget.Spinner;
+import android.widget.TextView;
+import android.widget.AdapterView.OnItemSelectedListener;
+
+/**
+ * Demonstrates how the various soft input modes impact window resizing.
+ */
+public class SoftInputModes extends Activity {
+    Spinner mResizeMode;
+    final CharSequence[] mResizeModeLabels = new CharSequence[] {
+            "Unspecified", "Resize", "Pan", "Nothing"
+    };
+    final int[] mResizeModeValues = new int[] {
+            WindowManager.LayoutParams.SOFT_INPUT_ADJUST_UNSPECIFIED,
+            WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE,
+            WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN,
+            WindowManager.LayoutParams.SOFT_INPUT_ADJUST_NOTHING,
+    };
+    
+    /**
+     * 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.soft_input_modes);
+        
+        mResizeMode = (Spinner)findViewById(R.id.resize_mode);
+        ArrayAdapter<CharSequence> adapter = new ArrayAdapter<CharSequence>(this,
+                android.R.layout.simple_spinner_item, mResizeModeLabels);
+        adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
+        mResizeMode.setAdapter(adapter);
+        mResizeMode.setSelection(0);
+        mResizeMode.setOnItemSelectedListener(
+                new OnItemSelectedListener() {
+                    public void onItemSelected(
+                            AdapterView<?> parent, View view, int position, long id) {
+                        getWindow().setSoftInputMode(mResizeModeValues[position]);
+                    }
+
+                    public void onNothingSelected(AdapterView<?> parent) {
+                        getWindow().setSoftInputMode(mResizeModeValues[0]);
+                    }
+                });
+    }
+}

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

@@ -0,0 +1,270 @@
+/*
+ * 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.Notification;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.ComponentName;
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.View;
+import android.widget.Button;
+import android.widget.RemoteViews;
+
+/**
+ * Demonstrates adding notifications to the status bar
+ */
+public class StatusBarNotifications extends Activity {
+
+    private NotificationManager mNotificationManager;
+
+    // Use our layout id for a unique identifier
+    private static int MOOD_NOTIFICATIONS = R.layout.status_bar_notifications;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        setContentView(R.layout.status_bar_notifications);
+
+        Button button;
+
+        // Get the notification manager serivce.
+        mNotificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
+
+        button = (Button) findViewById(R.id.happy);
+        button.setOnClickListener(new Button.OnClickListener() {
+            public void onClick(View v) {
+                setMood(R.drawable.stat_happy, R.string.status_bar_notifications_happy_message,
+                        false);
+            }
+        });
+
+        button = (Button) findViewById(R.id.neutral);
+        button.setOnClickListener(new Button.OnClickListener() {
+            public void onClick(View v) {
+                setMood(R.drawable.stat_neutral, R.string.status_bar_notifications_ok_message,
+                        false);
+            }
+        });
+
+        button = (Button) findViewById(R.id.sad);
+        button.setOnClickListener(new Button.OnClickListener() {
+            public void onClick(View v) {
+                setMood(R.drawable.stat_sad, R.string.status_bar_notifications_sad_message, false);
+            }
+        });
+
+        button = (Button) findViewById(R.id.happyMarquee);
+        button.setOnClickListener(new Button.OnClickListener() {
+            public void onClick(View v) {
+                setMood(R.drawable.stat_happy, R.string.status_bar_notifications_happy_message,
+                        true);
+            }
+        });
+
+        button = (Button) findViewById(R.id.neutralMarquee);
+        button.setOnClickListener(new Button.OnClickListener() {
+            public void onClick(View v) {
+                setMood(R.drawable.stat_neutral, R.string.status_bar_notifications_ok_message, true);
+            }
+        });
+
+        button = (Button) findViewById(R.id.sadMarquee);
+        button.setOnClickListener(new Button.OnClickListener() {
+            public void onClick(View v) {
+                setMood(R.drawable.stat_sad, R.string.status_bar_notifications_sad_message, true);
+            }
+        });
+
+        button = (Button) findViewById(R.id.happyViews);
+        button.setOnClickListener(new Button.OnClickListener() {
+            public void onClick(View v) {
+                setMoodView(R.drawable.stat_happy, R.string.status_bar_notifications_happy_message);
+            }
+        });
+
+        button = (Button) findViewById(R.id.neutralViews);
+        button.setOnClickListener(new Button.OnClickListener() {
+            public void onClick(View v) {
+                setMoodView(R.drawable.stat_neutral, R.string.status_bar_notifications_ok_message);
+            }
+        });
+
+        button = (Button) findViewById(R.id.sadViews);
+        button.setOnClickListener(new Button.OnClickListener() {
+            public void onClick(View v) {
+                setMoodView(R.drawable.stat_sad, R.string.status_bar_notifications_sad_message);
+            }
+        });
+        
+        button = (Button) findViewById(R.id.defaultSound);
+        button.setOnClickListener(new Button.OnClickListener() {
+            public void onClick(View v) {
+                setDefault(Notification.DEFAULT_SOUND);
+            }
+        });
+        
+        button = (Button) findViewById(R.id.defaultVibrate);
+        button.setOnClickListener(new Button.OnClickListener() {
+            public void onClick(View v) {
+                setDefault(Notification.DEFAULT_VIBRATE);
+            }
+        });
+        
+        button = (Button) findViewById(R.id.defaultAll);
+        button.setOnClickListener(new Button.OnClickListener() {
+            public void onClick(View v) {
+                setDefault(Notification.DEFAULT_ALL);
+            }
+        });
+        
+        button = (Button) findViewById(R.id.clear);
+        button.setOnClickListener(new Button.OnClickListener() {
+            public void onClick(View v) {
+                mNotificationManager.cancel(R.layout.status_bar_notifications);
+            }
+        });
+    }
+
+    private PendingIntent makeMoodIntent(int moodId) {
+        // The PendingIntent to launch our activity if the user selects this
+        // notification.  Note the use of FLAG_UPDATE_CURRENT so that if there
+        // is already an active matching pending intent, we will update its
+        // extras (and other Intents in the array) to be the ones passed in here.
+        PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
+                new Intent(this, NotificationDisplay.class).putExtra("moodimg", moodId),
+                PendingIntent.FLAG_UPDATE_CURRENT);
+        return contentIntent;
+    }
+    
+
+    private PendingIntent makeDefaultIntent() {
+        // 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(this,
+                com.example.android.apis.ApiDemos.class));
+
+        // "App"
+        intents[1] = new Intent(this, com.example.android.apis.ApiDemos.class);
+        intents[1].putExtra("com.example.android.apis.Path", "App");
+        // "App/Notification"
+        intents[2] = new Intent(this, com.example.android.apis.ApiDemos.class);
+        intents[2].putExtra("com.example.android.apis.Path", "App/Notification");
+
+        // Now the activity to display to the user.
+        intents[3] = new Intent(this, StatusBarNotifications.class);
+
+        // The PendingIntent to launch our activity if the user selects this
+        // notification.  Note the use of FLAG_UPDATE_CURRENT so that if there
+        // is already an active matching pending intent, we will update its
+        // extras (and other Intents in the array) to be the ones passed in here.
+        PendingIntent contentIntent = PendingIntent.getActivities(this, 0,
+                intents, PendingIntent.FLAG_UPDATE_CURRENT);
+        return contentIntent;
+    }
+
+
+    private void setMood(int moodId, int textId, boolean showTicker) {
+        // In this sample, we'll use the same text for the ticker and the expanded notification
+        CharSequence text = getText(textId);
+
+        // choose the ticker text
+        String tickerText = showTicker ? getString(textId) : null;
+
+        // Set the icon, scrolling text and timestamp
+        Notification notification = new Notification(moodId, tickerText,
+                System.currentTimeMillis());
+
+        // Set the info for the views that show in the notification panel.
+        notification.setLatestEventInfo(this, getText(R.string.status_bar_notifications_mood_title),
+                       text, makeMoodIntent(moodId));
+
+        // Send the notification.
+        // We use a layout id because it is a unique number.  We use it later to cancel.
+        mNotificationManager.notify(MOOD_NOTIFICATIONS, notification);
+    }
+
+    private void setMoodView(int moodId, int textId) {
+        // Instead of the normal constructor, we're going to use the one with no args and fill
+        // in all of the data ourselves.  The normal one uses the default layout for notifications.
+        // You probably want that in most cases, but if you want to do something custom, you
+        // can set the contentView field to your own RemoteViews object.
+        Notification notif = new Notification();
+
+        // This is who should be launched if the user selects our notification.
+        notif.contentIntent = makeMoodIntent(moodId);
+
+        // In this sample, we'll use the same text for the ticker and the expanded notification
+        CharSequence text = getText(textId);
+        notif.tickerText = text;
+
+        // the icon for the status bar
+        notif.icon = moodId;
+
+        // our custom view
+        RemoteViews contentView = new RemoteViews(getPackageName(), R.layout.status_bar_balloon);
+        contentView.setTextViewText(R.id.text, text);
+        contentView.setImageViewResource(R.id.icon, moodId);
+        notif.contentView = contentView;
+
+        // we use a string id because is a unique number.  we use it later to cancel the
+        // notification
+        mNotificationManager.notify(MOOD_NOTIFICATIONS, notif);
+    }
+    
+    private void setDefault(int defaults) {
+        
+        // This method sets the defaults on the notification before posting it.
+        
+        // This is who should be launched if the user selects our notification.
+        PendingIntent contentIntent = makeDefaultIntent();
+
+        // In this sample, we'll use the same text for the ticker and the expanded notification
+        CharSequence text = getText(R.string.status_bar_notifications_happy_message);
+
+        final Notification notification = new Notification(
+                R.drawable.stat_happy,       // the icon for the status bar
+                text,                        // the text to display in the ticker
+                System.currentTimeMillis()); // the timestamp for the notification
+
+        notification.setLatestEventInfo(
+                this,                        // the context to use
+                getText(R.string.status_bar_notifications_mood_title),
+                                             // the title for the notification
+                text,                        // the details to display in the notification
+                contentIntent);              // the contentIntent (see above)
+
+        notification.defaults = defaults;
+        
+        mNotificationManager.notify(
+                MOOD_NOTIFICATIONS, // we use a string id because it is a unique
+                                    // number.  we use it later to cancel the notification
+                notification);
+    }    
+}

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

@@ -0,0 +1,136 @@
+ /*
+ * 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 android.app.Activity;
+import android.os.Bundle;
+import android.speech.tts.TextToSpeech;
+import android.util.Log;
+import android.view.View;
+import android.widget.Button;
+
+import com.example.android.apis.R;
+
+import java.util.Locale;
+import java.util.Random;
+
+/**
+ * <p>Demonstrates text-to-speech (TTS). Please note the following steps:</p>
+ *
+ * <ol>
+ * <li>Construct the TextToSpeech object.</li>
+ * <li>Handle initialization callback in the onInit method.
+ * The activity implements TextToSpeech.OnInitListener for this purpose.</li>
+ * <li>Call TextToSpeech.speak to synthesize speech.</li>
+ * <li>Shutdown TextToSpeech in onDestroy.</li>
+ * </ol>
+ *
+ * <p>Documentation:
+ * http://developer.android.com/reference/android/speech/tts/package-summary.html
+ * </p>
+ * <ul>
+ */
+public class TextToSpeechActivity extends Activity implements TextToSpeech.OnInitListener {
+
+    private static final String TAG = "TextToSpeechDemo";
+
+    private TextToSpeech mTts;
+    private Button mAgainButton;
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.text_to_speech);
+
+        // Initialize text-to-speech. This is an asynchronous operation.
+        // The OnInitListener (second argument) is called after initialization completes.
+        mTts = new TextToSpeech(this,
+            this  // TextToSpeech.OnInitListener
+            );
+
+        // The button is disabled in the layout.
+        // It will be enabled upon initialization of the TTS engine.
+        mAgainButton = (Button) findViewById(R.id.again_button);
+
+        mAgainButton.setOnClickListener(new View.OnClickListener() {
+            public void onClick(View v) {
+                sayHello();
+            }
+        });
+    }
+
+    @Override
+    public void onDestroy() {
+        // Don't forget to shutdown!
+        if (mTts != null) {
+            mTts.stop();
+            mTts.shutdown();
+        }
+
+        super.onDestroy();
+    }
+
+    // Implements TextToSpeech.OnInitListener.
+    public void onInit(int status) {
+        // status can be either TextToSpeech.SUCCESS or TextToSpeech.ERROR.
+        if (status == TextToSpeech.SUCCESS) {
+            // Set preferred language to US english.
+            // Note that a language may not be available, and the result will indicate this.
+            int result = mTts.setLanguage(Locale.US);
+            // Try this someday for some interesting results.
+            // int result mTts.setLanguage(Locale.FRANCE);
+            if (result == TextToSpeech.LANG_MISSING_DATA ||
+                result == TextToSpeech.LANG_NOT_SUPPORTED) {
+               // Lanuage data is missing or the language is not supported.
+                Log.e(TAG, "Language is not available.");
+            } else {
+                // Check the documentation for other possible result codes.
+                // For example, the language may be available for the locale,
+                // but not for the specified country and variant.
+
+                // The TTS engine has been successfully initialized.
+                // Allow the user to press the button for the app to speak again.
+                mAgainButton.setEnabled(true);
+                // Greet the user.
+                sayHello();
+            }
+        } else {
+            // Initialization failed.
+            Log.e(TAG, "Could not initialize TextToSpeech.");
+        }
+    }
+
+    private static final Random RANDOM = new Random();
+    private static final String[] HELLOS = {
+      "Hello",
+      "Salutations",
+      "Greetings",
+      "Howdy",
+      "What's crack-a-lackin?",
+      "That explains the stench!"
+    };
+
+    private void sayHello() {
+        // Select a random hello.
+        int helloLength = HELLOS.length;
+        String hello = HELLOS[RANDOM.nextInt(helloLength)];
+        mTts.speak(hello,
+            TextToSpeech.QUEUE_FLUSH,  // Drop all pending entries in the playback queue.
+            null);
+    }
+
+}