Home | History | Annotate | Download | only in shadows 
      1 package org.robolectric.shadows;
      2 
      3 import android.content.Context;
      4 import android.net.wifi.p2p.WifiP2pGroup;
      5 import android.net.wifi.p2p.WifiP2pManager;
      6 import android.net.wifi.p2p.WifiP2pManager.ActionListener;
      7 import android.net.wifi.p2p.WifiP2pManager.Channel;
      8 import android.os.Handler;
      9 import android.os.Looper;
     10 import com.google.common.base.Preconditions;
     11 import java.util.HashMap;
     12 import java.util.Map;
     13 import org.robolectric.annotation.Implementation;
     14 import org.robolectric.annotation.Implements;
     15 import org.robolectric.util.ReflectionHelpers;
     16 
     17 @Implements(WifiP2pManager.class)
     18 public class ShadowWifiP2pManager {
     19 
     20   private static final int NO_FAILURE = -1;
     21 
     22   private int listeningChannel;
     23   private int operatingChannel;
     24   private WifiP2pManager.GroupInfoListener groupInfoListener;
     25   private Handler handler;
     26   private int nextActionFailure = NO_FAILURE;
     27   private Map<Channel, WifiP2pGroup> p2pGroupmap = new HashMap<>();
     28 
     29   public int getListeningChannel() {
     30     return listeningChannel;
     31   }
     32 
     33   public int getOperatingChannel() {
     34     return operatingChannel;
     35   }
     36 
     37   public WifiP2pManager.GroupInfoListener getGroupInfoListener() {
     38     return groupInfoListener;
     39   }
     40 
     41   @Implementation
     42   public void setWifiP2pChannels(
     43       Channel c, int listeningChannel, int operatingChannel, ActionListener al) {
     44     Preconditions.checkNotNull(c);
     45     Preconditions.checkNotNull(al);
     46     this.listeningChannel = listeningChannel;
     47     this.operatingChannel = operatingChannel;
     48   }
     49 
     50   @Implementation
     51   public Channel initialize(Context context, Looper looper, WifiP2pManager.ChannelListener listener) {
     52     handler = new Handler(looper);
     53     return ReflectionHelpers.newInstance(Channel.class);
     54   }
     55 
     56   @Implementation
     57   public void createGroup(Channel c, ActionListener al) {
     58     postActionListener(al);
     59   }
     60 
     61   private void postActionListener(final ActionListener al) {
     62     if (al == null) {
     63       return;
     64     }
     65 
     66     handler.post(new Runnable() {
     67       @Override
     68       public void run() {
     69         if (nextActionFailure == -1) {
     70           al.onSuccess();
     71         } else {
     72           al.onFailure(nextActionFailure);
     73         }
     74         nextActionFailure = NO_FAILURE;
     75       }
     76     });
     77   }
     78 
     79   @Implementation
     80   public void requestGroupInfo(final Channel c, final WifiP2pManager.GroupInfoListener gl) {
     81     if (gl == null) {
     82       return;
     83     }
     84 
     85     handler.post(new Runnable() {
     86       @Override
     87       public void run() {
     88         gl.onGroupInfoAvailable(p2pGroupmap.get(c));
     89       }
     90     });
     91   }
     92 
     93   @Implementation
     94   public void removeGroup(Channel c, ActionListener al) {
     95     postActionListener(al);
     96   }
     97 
     98   public void setNextActionFailure(int nextActionFailure) {
     99     this.nextActionFailure = nextActionFailure;
    100   }
    101 
    102   public void setGroupInfo(Channel channel, WifiP2pGroup wifiP2pGroup) {
    103     p2pGroupmap.put(channel, wifiP2pGroup);
    104   }
    105 }
    106