Android: Как использовать коммутационный футляр с намерениями, полученными от трансляций

Question

Я хочу проанализировать намерение получать из трансляции. Потому что могут быть разные намерения из разных передач. Для оценки различных передач я хочу использовать switch case подобное заявление:

public void onReceive(Context context, Intent intent) { 
    switch (intent.getAction()) { 
    case Intent.ACTION_SCREEN_OFF: 
     //code for this intent 
    } 
} 

Но я знаю, что это не возможно создать переключатель случай заявление, как это, так что я думаю, что нужно что-то вроде целого значения для идентификации намерения, но я не могу найти способ получить такую ​​ценность от своих намерений.

Может ли кто-нибудь сказать мне, как анализировать различные намерения с помощью заявления switch case?

Edit: Работает с else-if, но я хочу использовать switch-case

Answer 1

Все Intent.ACTION_ * поля постоянны строки.

Вы не можете использовать переключатель со строкой до JDK 7 android использовать JDK 6 или 5 для компиляции. Таким образом, вы не можете использовать этот метод на Android

Но вы можете использовать else if

if (intent.getAction().equals(Intent.ACTION_SCREEN_OFF) { 
    // Do 
} else if (intent.getAction().equals(Intent.ANYTINGS) { 
    //do 
} 

Official documentation

Answer 2

Я хочу использовать переключатель случая заявление тоже.
Так я создаю пользовательский класс перечислимого, что его конструктор требует намерения струнного действия, как показано ниже:
(потому что перечисление может быть использованы для включения саза)

enum ACTION { 
    INVALID("action.invalid"), // action for ignore. 
    FOO("action.foo"), 
    BAR("action.bar"),; 

    private final String action; 

    ACTION(String action) { 
     this.action = action; 
    } 

    public String getAction() { // to use it for intentFilter. 
     return action; 
    } 

    public static ACTION getEnum(String action) { 
     for (ACTION act : values()) { 
      if (act.action.equals(action)) return act; 
     } 
     return INVALID; // do not throw exception like IllegalArgumentException or else. throw exception may disturb your code refactoring. 
    } 

    // example - just broadcast 
    public void broadcast(Context ctx, PARAM.Abstract p) { // I will explain PARAM class later. 
     Intent intent = new Intent(); 
     intent.setAction(action); 
     p.injectExtras(intent); // see impl below! 

     ctx.sendBroadcast(intent); 
    } 

    // example - use AlarmManager 
    public void alarm(Context ctx, Date time, PARAM.Abstract p) { 
     Intent intent = new Intent(); 
     intent.setAction(action); 
     p.injectExtras(intent); // see impl below! 

     AlarmManager alarmManager = (AlarmManager) ctx.getSystemService(Context.ALARM_SERVICE); 
     PendingIntent pendingIntent = PendingIntent.getBroadcast(ctx, 0, intent, 0); 
     alarmManager.set(AlarmManager.RTC, time.getTime(), pendingIntent); 
    } 

    // of course, you can use ctx.startService, or else.  
} 

использования пример:

// trigger it. 
ACTION.FOO.broadcast(context,new PARAM.Abstract()); 

... 

// receive & handle it. 
public void onReceive(Context context, Intent intent) { 
    final String action = intent.getAction(); 
    ACTION anEnum = ACTION.getEnum(action); 
    switch (anEnum) { 
     case INVALID: // it can be occured by old version's legacy alarm. 
      Log.w("INVALID action occured:"+action); 
      break; 
     case FOO: 
      // do something for FOO 
      break; 
     case BAR: 
      // do something for FOO 
      break; 
     defalut: 
      Log.d("Unimplement! action:"+action); 
      break; 
    } 
} 

... 

// and I recommend below, when register broadcast receiver. 
// create this method below of onReceive. 
private IntentFilter getIntentFilter() { 
    IntentFilter filter = new IntentFilter(); 
    filter.addAction(ACTION.FOO.getAction()); 
    filter.addAction(ACTION.BAR.getAction()); 
    return filter; 
} 

... 

// register your receiver like this 
BroadcastReceiver my = new MyBroadcastReceiver(); 
registerReceiver(my, my.getIntentFilter()); 

объясните PARMA.Abstrat
Использование перечисления для трансляции удобно.
Это уменьшает работу, любит печатать коды (} else if(action.equals("blahblah") {) и объявлять действия (static final ACTION_FOO="action.foo").
, но .. когда вам нужно добавить некоторые дополнительные функции для отправки чего-либо другому компоненту, вы можете узнать, что нет способа сделать это как ACTION.FOO.broadcastWithParam(p);. даже если вы внедрили broadcastWithParam() на FOO, вы не можете получить доступ к методу broadcastWithParam(). потому что это как работает enum (см. this thread для подробностей) , поэтому нам нужно сделать что-то другое. В моем случае я решил использовать класс (PARAM).
заявляют:

class PARAM { 
    public static class Abstract { 
     protected void injectExtras(Intent intent){ 
      // do nothing for action don't need to extas... 
     } 
    } 

    public static class FOO extends Abstract { // this is for ACTION.FOO 
     public static final String P1_KEY="p1"; 
     public static final String P2_KEY="p2"; 

     String p1; 
     int p2; 

     public FOO(String p1, int p2){ 
      this.p1 =p1; 
      this.p2 =p2; 
     } 

     @Override 
     protected void injectExtras(Intent intent){ 
      intent.putExtra(P1_KEY,this.p1); 
      intent.putExtra(P2_KEY,this.p2); 
     } 
    } 

    public static class BAR extends Abstract{ // this is for ACTION.BAR 
     ... 
    } 
} 

использование пример:

public void onReceive(Context context, Intent intent) { 
    final String action = intent.getAction(); 
    ACTION anEnum = ACTION.getEnum(action); 
    switch (anEnum) { 
     case FOO: 
      Bundle extras = intent.getExtras(); 
      String p1 = extras.getString(PARAM.FOO.P1_KEY); 
      int p2 = extras.getString(PARAM.FOO.P2_KEY); 
      // do something with p1 & p2; 
      break; 
    } 
} 

Наконец, Я использую «ACTION & PARAM` в качестве внутреннего класса обслуживания, BroadcastReceiver или другого.
пример:

public class MyIntentService extends IntentService { 

    @Override 
    protected void onHandleIntent(Intent intent) { 
     if (intent != null) { 
      final String action = intent.getAction(); 
      ACTION anEnum = ACTION.getEnum(action); 
      switch (anEnum) { 
       case INVALID: // it can be occured by old version's legacy alarm. 
        Log.w("INVALID action occured:"+action); 
        break; 
       case FOO: 
        // do something for FOO 
        break; 
       case BAR: 
        // do something for FOO 
        break; 
       defalut: 
        Log.d("Unimplement! action:"+action); 
        break; 
      } 
     } 
    } 

    public static enum ACTION {...} 

    public static class PARAM {...} 
} 

Answer 3

3 месяца назад, я ответил на этот вопрос. теперь у меня есть идея лучше, чем раньше.

Просто вы не должны использовать оператор switch в методе onReceive. Потому что есть более эффективный способ, чем он. Используйте отражение, чтобы сделать каждую рукоятку помощника цели!

см код ниже:

public class SOReceiver extends BroadcastReceiver { 

    @Override 
    public void onReceive(Context context, Intent intent) {INTENT.onHandleIntent(this, intent);} 

    public static class INTENT { 
     public static void onHandleIntent(SOReceiver intentService, Intent intent) { 
      for (Class<?> clazz : INTENT.class.getDeclaredClasses()) { 
       // note: this code use getSimpleName! 
       if (clazz.getSimpleName().equals(intent.getAction())) { 
        try { 
         IntentInterface instance = (IntentInterface) clazz.newInstance(); 
         instance.onReceive(intentService, intent); 
        } catch (Exception e) { 
         e.printStackTrace(); 
        } 
        return; 
       } 
      } 
      // unexpected INTENT arrived. 
     } 

     private static interface IntentInterface { 
      void onReceive(SOReceiver intentService, Intent intent); 
     } 

     public static class EACH_ACTION implements IntentInterface { 
      // usage ex: SOReceiver.INTENT.EACH_ACTION.start(context,3.0,1); 
      private static final String PARAM_FOO = "PARAM_FOO"; 
      private static final String PARAM_BAR = "PARAM_BAR"; 

      public static void start(Context context, double foo, int bar) { 
       Intent intent = new Intent(); 
       intent.setAction(EACH_ACTION.class.getSimpleName()); // necessary 
       intent.setClass(context, SOReceiver.class); // optional, but recommended. 
       intent.putExtra(PARAM_FOO,foo); 
       intent.putExtra(PARAM_BAR,bar); 
       context.sendBroadcast(intent); 
       // or if you want to use this as pending intent. 
       // PendingIntent.getBroadcast(context,0,intent,0); 
      } 

      @Override 
      public void onReceive(SOReceiver intentService, Intent intent) { 
       Bundle extras = intent.getExtras(); 
       double foo = extras.getDouble(PARAM_FOO); 
       int bar = extras.getInt(PARAM_BAR); 
       // ... do what ever you want to do with this intent and parameters ... 
      } 
     } 
    } 
} 

это лучше, чем старшем ответ. он короток, легко читается и легко добавляет больше намерений.