gametel 0.1

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

@@ -0,0 +1,169 @@
+/*
+ * 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.Notification;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.Intent;
+import android.os.Binder;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.Message;
+import android.os.Messenger;
+import android.os.RemoteException;
+import android.util.Log;
+import android.widget.Toast;
+
+import java.util.ArrayList;
+
+// 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 com.example.android.apis.app.RemoteService.Controller;
+
+/**
+ * This is an example of implementing an application service that uses the
+ * {@link Messenger} class for communicating with clients.  This allows for
+ * remote interaction with a service, without needing to define an AIDL
+ * interface.
+ *
+ * <p>Notice the use of the {@link NotificationManager} when interesting things
+ * happen in the service.  This is generally how background services should
+ * interact with the user, rather than doing something more disruptive such as
+ * calling startActivity().
+ */
+
+public class MessengerService extends Service {
+    /** For showing and hiding our notification. */
+    NotificationManager mNM;
+    /** Keeps track of all current registered clients. */
+    ArrayList<Messenger> mClients = new ArrayList<Messenger>();
+    /** Holds last value set by a client. */
+    int mValue = 0;
+    
+    /**
+     * Command to the service to register a client, receiving callbacks
+     * from the service.  The Message's replyTo field must be a Messenger of
+     * the client where callbacks should be sent.
+     */
+    static final int MSG_REGISTER_CLIENT = 1;
+    
+    /**
+     * Command to the service to unregister a client, ot stop receiving callbacks
+     * from the service.  The Message's replyTo field must be a Messenger of
+     * the client as previously given with MSG_REGISTER_CLIENT.
+     */
+    static final int MSG_UNREGISTER_CLIENT = 2;
+    
+    /**
+     * Command to service to set a new value.  This can be sent to the
+     * service to supply a new value, and will be sent by the service to
+     * any registered clients with the new value.
+     */
+    static final int MSG_SET_VALUE = 3;
+    
+    /**
+     * Handler of incoming messages from clients.
+     */
+    class IncomingHandler extends Handler {
+        @Override
+        public void handleMessage(Message msg) {
+            switch (msg.what) {
+                case MSG_REGISTER_CLIENT:
+                    mClients.add(msg.replyTo);
+                    break;
+                case MSG_UNREGISTER_CLIENT:
+                    mClients.remove(msg.replyTo);
+                    break;
+                case MSG_SET_VALUE:
+                    mValue = msg.arg1;
+                    for (int i=mClients.size()-1; i>=0; i--) {
+                        try {
+                            mClients.get(i).send(Message.obtain(null,
+                                    MSG_SET_VALUE, mValue, 0));
+                        } catch (RemoteException e) {
+                            // The client is dead.  Remove it from the list;
+                            // we are going through the list from back to front
+                            // so this is safe to do inside the loop.
+                            mClients.remove(i);
+                        }
+                    }
+                    break;
+                default:
+                    super.handleMessage(msg);
+            }
+        }
+    }
+    
+    /**
+     * Target we publish for clients to send messages to IncomingHandler.
+     */
+    final Messenger mMessenger = new Messenger(new IncomingHandler());
+    
+    @Override
+    public void onCreate() {
+        mNM = (NotificationManager)getSystemService(NOTIFICATION_SERVICE);
+
+        // Display a notification about us starting.
+        showNotification();
+    }
+
+    @Override
+    public void onDestroy() {
+        // Cancel the persistent notification.
+        mNM.cancel(R.string.remote_service_started);
+
+        // Tell the user we stopped.
+        Toast.makeText(this, R.string.remote_service_stopped, Toast.LENGTH_SHORT).show();
+    }
+    
+    /**
+     * When binding to the service, we return an interface to our messenger
+     * for sending messages to the service.
+     */
+    @Override
+    public IBinder onBind(Intent intent) {
+        return mMessenger.getBinder();
+    }
+
+    /**
+     * 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.remote_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, Controller.class), 0);
+
+        // Set the info for the views that show in the notification panel.
+        notification.setLatestEventInfo(this, getText(R.string.remote_service_label),
+                       text, contentIntent);
+
+        // Send the notification.
+        // We use a string id because it is a unique number.  We use it later to cancel.
+        mNM.notify(R.string.remote_service_started, notification);
+    }
+}
+

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

@@ -0,0 +1,178 @@
+package com.example.android.apis.app;
+
+import com.example.android.apis.R;
+import com.example.android.apis.app.LocalServiceActivities.Binding;
+
+import android.app.Activity;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.Message;
+import android.os.Messenger;
+import android.os.RemoteException;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.TextView;
+import android.widget.Toast;
+
+public class MessengerServiceActivities {
+    /**
+     * Example of binding and unbinding to the remote service.
+     * This demonstrates the implementation of a service which the client will
+     * bind to, interacting with it through an aidl interface.</p>
+     * 
+     * <p>Note that this is implemented as an inner class only keep the sample
+     * all together; typically this code would appear in some separate class.
+     */
+    public static class Binding extends Activity {
+
+        /** Messenger for communicating with service. */
+        Messenger mService = null;
+        /** Flag indicating whether we have called bind on the service. */
+        boolean mIsBound;
+        /** Some text view we are using to show state information. */
+        TextView mCallbackText;
+        
+        /**
+         * Handler of incoming messages from service.
+         */
+        class IncomingHandler extends Handler {
+            @Override
+            public void handleMessage(Message msg) {
+                switch (msg.what) {
+                    case MessengerService.MSG_SET_VALUE:
+                        mCallbackText.setText("Received from service: " + msg.arg1);
+                        break;
+                    default:
+                        super.handleMessage(msg);
+                }
+            }
+        }
+        
+        /**
+         * Target we publish for clients to send messages to IncomingHandler.
+         */
+        final Messenger mMessenger = new Messenger(new IncomingHandler());
+        
+        /**
+         * Class for interacting with the main interface of the service.
+         */
+        private ServiceConnection mConnection = new ServiceConnection() {
+            public void onServiceConnected(ComponentName className,
+                    IBinder service) {
+                // This is called when the connection with the service has been
+                // established, giving us the service object we can use to
+                // interact with the service.  We are communicating with our
+                // service through an IDL interface, so get a client-side
+                // representation of that from the raw service object.
+                mService = new Messenger(service);
+                mCallbackText.setText("Attached.");
+
+                // We want to monitor the service for as long as we are
+                // connected to it.
+                try {
+                    Message msg = Message.obtain(null,
+                            MessengerService.MSG_REGISTER_CLIENT);
+                    msg.replyTo = mMessenger;
+                    mService.send(msg);
+                    
+                    // Give it some value as an example.
+                    msg = Message.obtain(null,
+                            MessengerService.MSG_SET_VALUE, this.hashCode(), 0);
+                    mService.send(msg);
+                } catch (RemoteException e) {
+                    // In this case the service has crashed before we could even
+                    // do anything with it; we can count on soon being
+                    // disconnected (and then reconnected if it can be restarted)
+                    // so there is no need to do anything here.
+                }
+                
+                // As part of the sample, tell the user what happened.
+                Toast.makeText(Binding.this, R.string.remote_service_connected,
+                        Toast.LENGTH_SHORT).show();
+            }
+
+            public void onServiceDisconnected(ComponentName className) {
+                // This is called when the connection with the service has been
+                // unexpectedly disconnected -- that is, its process crashed.
+                mService = null;
+                mCallbackText.setText("Disconnected.");
+
+                // As part of the sample, tell the user what happened.
+                Toast.makeText(Binding.this, R.string.remote_service_disconnected,
+                        Toast.LENGTH_SHORT).show();
+            }
+        };
+        
+        void doBindService() {
+            // Establish a connection with the service.  We use an explicit
+            // class name because there is no reason to be able to let other
+            // applications replace our component.
+            bindService(new Intent(Binding.this, 
+                    MessengerService.class), mConnection, Context.BIND_AUTO_CREATE);
+            mIsBound = true;
+            mCallbackText.setText("Binding.");
+        }
+        
+        void doUnbindService() {
+            if (mIsBound) {
+                // If we have received the service, and hence registered with
+                // it, then now is the time to unregister.
+                if (mService != null) {
+                    try {
+                        Message msg = Message.obtain(null,
+                                MessengerService.MSG_UNREGISTER_CLIENT);
+                        msg.replyTo = mMessenger;
+                        mService.send(msg);
+                    } catch (RemoteException e) {
+                        // There is nothing special we need to do if the service
+                        // has crashed.
+                    }
+                }
+                
+                // Detach our existing connection.
+                unbindService(mConnection);
+                mIsBound = false;
+                mCallbackText.setText("Unbinding.");
+            }
+        }
+
+        
+        /**
+         * Standard initialization of this activity.  Set up the UI, then wait
+         * for the user to poke it before doing anything.
+         */
+        @Override
+        protected void onCreate(Bundle savedInstanceState) {
+            super.onCreate(savedInstanceState);
+
+            setContentView(R.layout.messenger_service_binding);
+
+            // Watch for button clicks.
+            Button button = (Button)findViewById(R.id.bind);
+            button.setOnClickListener(mBindListener);
+            button = (Button)findViewById(R.id.unbind);
+            button.setOnClickListener(mUnbindListener);
+            
+            mCallbackText = (TextView)findViewById(R.id.callback);
+            mCallbackText.setText("Not attached.");
+        }
+
+        private OnClickListener mBindListener = new OnClickListener() {
+            public void onClick(View v) {
+                doBindService();
+            }
+        };
+
+        private OnClickListener mUnbindListener = new OnClickListener() {
+            public void onClick(View v) {
+                doUnbindService();
+            }
+        };
+    }
+}

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

@@ -0,0 +1,82 @@
+/*
+ * 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.NotificationManager;
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.View;
+import android.view.WindowManager;
+import android.widget.ImageButton;
+import android.widget.RelativeLayout;
+
+/**
+ * Activity used by StatusBarNotification to show the notification to the user.
+ */
+public class NotificationDisplay extends Activity implements View.OnClickListener {
+    /**
+     * 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 icicle) {
+        // Be sure to call the super class.
+        super.onCreate(icicle);
+
+        // Have the system blur any windows behind this one.
+        getWindow().setFlags(WindowManager.LayoutParams.FLAG_BLUR_BEHIND,
+                WindowManager.LayoutParams.FLAG_BLUR_BEHIND);
+        
+        RelativeLayout container = new RelativeLayout(this);
+        
+        ImageButton button = new ImageButton(this);
+        button.setImageResource(getIntent().getIntExtra("moodimg", 0));
+        button.setOnClickListener(this);
+        
+        RelativeLayout.LayoutParams lp = new RelativeLayout.LayoutParams(
+                RelativeLayout.LayoutParams.WRAP_CONTENT,
+                RelativeLayout.LayoutParams.WRAP_CONTENT);
+        lp.addRule(RelativeLayout.CENTER_IN_PARENT);
+        
+        container.addView(button, lp);
+        
+        setContentView(container);
+    }
+
+    public void onClick(View v) {
+        // The user has confirmed this notification, so remove it.
+        ((NotificationManager) getSystemService(NOTIFICATION_SERVICE))
+                .cancel(R.layout.status_bar_notifications);
+        
+        // Pressing on the button brings the user back to our mood ring,
+        // as part of the api demos app.  Note the use of NEW_TASK here,
+        // since the notification display activity is run as a separate task.
+        Intent intent = new Intent(this, StatusBarNotifications.class);
+        intent.setAction(Intent.ACTION_MAIN);
+        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        startActivity(intent);
+        
+        // We're done.
+        finish();
+    }
+}

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

@@ -0,0 +1,80 @@
+/*
+ * 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.widget.Button;
+import android.os.Bundle;
+import android.view.View;
+import android.widget.Toast;
+
+/**
+ * When you push the button on this Activity, it creates a {@link Toast} object and
+ * using the Toast method.
+ * @see Toast
+ * @see Toast#makeText(android.content.Context,int,int)
+ * @see Toast#makeText(android.content.Context,java.lang.CharSequence,int)
+ * @see Toast#LENGTH_SHORT
+ * @see Toast#LENGTH_LONG
+ */
+public class NotifyWithText extends Activity {
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        setContentView(R.layout.notify_with_text);
+
+        Button button;
+
+        // short notification
+        button = (Button) findViewById(R.id.short_notify);
+        button.setOnClickListener(new Button.OnClickListener() {
+            public void onClick(View v) {
+                // Note that we create the Toast object and call the show() method
+                // on it all on one line.  Most uses look like this, but there
+                // are other methods on Toast that you can call to configure how
+                // it appears.
+                //
+                // Note also that we use the version of makeText that takes a
+                // resource id (R.string.short_notification_text).  There is also
+                // a version that takes a CharSequence if you must construct
+                // the text yourself.
+                Toast.makeText(NotifyWithText.this, R.string.short_notification_text,
+                    Toast.LENGTH_SHORT).show();
+            }
+        });
+
+        // long notification
+        // The only difference here is that the notification stays up longer.
+        // You might want to use this if there is more text that they're going
+        // to read.
+        button = (Button) findViewById(R.id.long_notify);
+        button.setOnClickListener(new Button.OnClickListener() {
+            public void onClick(View v) {
+                Toast.makeText(NotifyWithText.this, R.string.long_notification_text,
+                    Toast.LENGTH_LONG).show();
+            }
+        });
+
+
+
+
+
+    }
+}