Exemplo n.º 1
0
  private void remainingSecondsChanged(int newVal) {
    mRemainingSecs = newVal;
    if (newVal == 0) {
      // Countdown has finished
      setVisibility(View.INVISIBLE);
      if (mListener != null) mListener.onCountDownFinished();
    } else {
      Locale locale = getResources().getConfiguration().locale;
      String localizedValue = String.format(locale, "%d", newVal);
      mRemainingSecondsView.setText(localizedValue);
      // Fade-out animation
      mCountDownAnim.reset();
      mRemainingSecondsView.clearAnimation();
      mRemainingSecondsView.startAnimation(mCountDownAnim);

      // Play sound effect for the last 3 seconds of the countdown
      //			if (mPlaySound) {
      //				if (newVal == 1) {
      //					mSoundPool.play(mBeepTwice, 1.0f, 1.0f, 0, 0, 1.0f);
      //				} else if (newVal <= 3) {
      //					mSoundPool.play(mBeepOnce, 1.0f, 1.0f, 0, 0, 1.0f);
      //				}
      //			}
      // Schedule the next remainingSecondsChanged() call in 1 second
      mHandler.sendEmptyMessageDelayed(SET_TIMER_TEXT, 1000);
    }
  }
 private void displayMissedCalls(final int missedCallsCount) {
   if (missedCallsCount > 0) {
     missedCalls.setText(missedCallsCount + "");
     missedCalls.setVisibility(View.VISIBLE);
     if (!isAnimationDisabled) {
       missedCalls.startAnimation(
           AnimationUtils.loadAnimation(LinphoneActivity.this, R.anim.bounce));
     }
   } else {
     missedCalls.clearAnimation();
     missedCalls.setVisibility(View.GONE);
   }
 }
Exemplo n.º 3
0
 private void makeBadgeVisible() {
   synchronized (lock) {
     // show the badge, canceling the "fade out" animation if necessary
     TransitionDrawable transitionDrawable =
         (TransitionDrawable) badgeLinearLayout.getBackground();
     transitionDrawable.resetTransition();
     if (badgeTextView.getAnimation() != null) {
       badgeTextView.clearAnimation();
     }
     badgeTextView.setVisibility(View.VISIBLE);
     badgeLinearLayout.setVisibility(View.VISIBLE);
   }
 }
Exemplo n.º 4
0
  @Override
  public View getView(int position, View convertView, ViewGroup parent) {
    View v = convertView;
    if (convertView == null) {
      v = inflater.inflate(R.layout.list_radio_item, null);
    }

    ImageView stt = (ImageView) v.findViewById(R.id.imageViewRadioStat);
    TextView tvNama = (TextView) v.findViewById(R.id.textViewNamaRadio);
    TextView tvKota = (TextView) v.findViewById(R.id.textViewKota);
    ImageView blink = (ImageView) v.findViewById(R.id.imageViewRadioBlink);
    TextView tvStat = (TextView) v.findViewById(R.id.textViewStatus);

    Radio r = data.get(position);
    Animation anim = new AlphaAnimation(0.0f, 1.0f);
    anim.setDuration(500);
    anim.setStartOffset(200);
    anim.setRepeatMode(Animation.REVERSE);
    anim.setRepeatCount(Animation.INFINITE);

    if (url.equals(r.getUrl()) && isPlayed && serviceRunning && onRadio) {
      r.setPlayedAtm(true);
      r.setStatusMessage("Menjalankan");
      isPlayed = false;
    }

    tvNama.setText(r.getNamaRadio());
    //		int c = tvNama.getTextColors().getDefaultColor();
    tvKota.setText(r.getKota());
    if (r.isPlayedAtm()) {
      tvNama.setTextColor(_ac.getResources().getColor(R.color.hijau_1));
      stt.setImageResource(R.drawable.ic_radio_on);
      blink.setImageResource(R.drawable.lingkaran_kecil);
      blink.startAnimation(anim);
      tvStat.setText(r.getStatusMessage());
      tvStat.startAnimation(anim);
    } else {
      tvNama.setTextColor(Color.WHITE);
      stt.setImageResource(R.drawable.ic_radio_off);
      blink.setImageResource(android.R.color.transparent);
      blink.clearAnimation();
      if (r.getStatusMessage().equalsIgnoreCase("Error")) {
        tvStat.setText("Tidak ada koneksi.");
      } else {
        tvStat.setText("");
      }
      tvStat.clearAnimation();
    }

    return v;
  }
  public void showPageNumber(boolean force) {
    if (pageNumberAnim == null) {
      pageNumberTextView.setVisibility(View.GONE);
      return;
    }

    pageNumberTextView.setVisibility(View.VISIBLE);
    String newText =
        "" + (this.pagesView.getCurrentPage() + 1) + "/" + this.pdfPagesProvider.getPageCount();

    if (!force && newText.equals(pageNumberTextView.getText())) return;

    pageNumberTextView.setText(newText);
    pageNumberTextView.clearAnimation();

    pageHandler.removeCallbacks(pageRunnable);
    pageHandler.postDelayed(pageRunnable, fadeStartOffset);
  }
Exemplo n.º 6
0
  /** Disables the animations. */
  public void reset() {
    mCancelled = true;

    if (mAnimationStartRunnable != null) {
      removeCallbacks(mAnimationStartRunnable);
    }

    mTextField.clearAnimation();
    mStarted = false;

    mMoveTextOut.reset();
    mMoveTextIn.reset();

    //        mScrollView.removeView(mTextField);
    //        mScrollView.addView(mTextField);

    invalidate();
  }
Exemplo n.º 7
0
  public void loadOut() {
    Animation animation = AnimationUtils.loadAnimation(this, R.anim.slide_out_left_delay);
    Animation animation2 = AnimationUtils.loadAnimation(this, R.anim.slide_out_left_delay);
    Animation animation3 = AnimationUtils.loadAnimation(this, R.anim.slide_out_left_delay);
    Animation fadeAnimation = AnimationUtils.loadAnimation(this, R.anim.fade_out);
    overLay.clearAnimation();
    overLay.setAnimation(animation);
    overLay2.clearAnimation();
    overLay2.setAnimation(animation2);
    overLay3.clearAnimation();
    overLay3.setAnimation(animation3);
    welcomeText.clearAnimation();
    welcomeText.setAnimation(fadeAnimation);

    fadeAnimation.setStartOffset(1500);
    animation.setStartOffset(2000);
    animation2.setStartOffset(2100);
    animation3.setStartOffset(2200);

    welcomeText.setVisibility(View.GONE);
    overLay.setVisibility(View.GONE);
    overLay2.setVisibility(View.GONE);
    overLay3.setVisibility(View.GONE);

    animation3.setAnimationListener(
        new Animation.AnimationListener() {
          @Override
          public void onAnimationStart(Animation animation) {}

          @Override
          public void onAnimationEnd(Animation animation) {

            dashBoard();
          }

          @Override
          public void onAnimationRepeat(Animation animation) {}
        });
  }
 void reset(boolean animate) {
   setState(STATE_NORMAL);
   text.setVisibility(View.VISIBLE);
   text.setTextAppearance(text.getContext(), R.style.TextAppearance_SlidingTabNormal);
   tab.setVisibility(View.VISIBLE);
   target.setVisibility(View.INVISIBLE);
   final boolean horiz = alignment == ALIGN_LEFT || alignment == ALIGN_RIGHT;
   int dx =
       horiz
           ? (alignment == ALIGN_LEFT
               ? alignment_value - tab.getLeft()
               : alignment_value - tab.getRight())
           : 0;
   int dy =
       horiz
           ? 0
           : (alignment == ALIGN_TOP
               ? alignment_value - tab.getTop()
               : alignment_value - tab.getBottom());
   if (animate) {
     TranslateAnimation trans = new TranslateAnimation(0, dx, 0, dy);
     trans.setDuration(ANIM_DURATION);
     trans.setFillAfter(false);
     text.startAnimation(trans);
     tab.startAnimation(trans);
   } else {
     if (horiz) {
       text.offsetLeftAndRight(dx);
       tab.offsetLeftAndRight(dx);
     } else {
       text.offsetTopAndBottom(dy);
       tab.offsetTopAndBottom(dy);
     }
     text.clearAnimation();
     tab.clearAnimation();
     target.clearAnimation();
   }
 }
  public void reset() {
    Log.d(TAG, "Resetting animation.");

    mCancelled = true;

    if (mAnimation1StartRunnable != null) {
      removeCallbacks(mAnimation1StartRunnable);
    }

    mTextField1.clearAnimation();

    prepareTextFields();

    mMoveText1TextOut.reset();
    mMoveText1TextIn.reset();

    mScrollView1.removeView(mTextField1);
    mScrollView1.addView(mTextField1);

    mTextField1.setEllipsize(TextUtils.TruncateAt.END);

    invalidate();
  }
Exemplo n.º 10
0
  @Override
  public void onCreate(Bundle savedInstanceState) {
    Log.d("Sub", "On-Create");
    super.onCreate(savedInstanceState);
    setContentView(R.layout.chart);

    sustainability_v2 obj = new sustainability_v2();
    obj.sum_smallDistance = 0;
    obj.sum_largeDistance = 0;
    obj.prev_points = 25;
    obj.calculate_Distance();

    rank_calc obj_rank = new rank_calc();
    ImageView img = (ImageView) findViewById(R.id.imageView3);
    img.setVisibility(8);
    txt = (TextView) findViewById(R.id.value);
    String deviceID;
    deviceID = Secure.getString(getBaseContext().getContentResolver(), Secure.ANDROID_ID);
    obj_rank.getRank(deviceID);
    if (isNetworkAvailable()) {
      if (obj_rank.rank == null) {
        txt.setText("\t Sorry,Server problem");
      } else {
        txt.setText(" Your rank is " + obj_rank.rank + " among " + obj_rank.count + " users");
      }
    } else {
      txt.setText("\t Sorry,No network coverage!");
    }
    txt.setVisibility(8);
    AnimationSet c = (AnimationSet) AnimationUtils.loadAnimation(this, R.layout.flash);

    c.setRepeatMode(Animation.REVERSE);
    c.setRepeatCount(Animation.INFINITE);
    txt.clearAnimation();
    txt.startAnimation(c);

    c = (AnimationSet) AnimationUtils.loadAnimation(this, R.layout.flash);

    c.setRepeatMode(Animation.REVERSE);
    c.setRepeatCount(Animation.INFINITE);
    txt.clearAnimation();
    txt.startAnimation(c);

    c = (AnimationSet) AnimationUtils.loadAnimation(this, R.layout.flash);

    c.setRepeatMode(Animation.REVERSE);
    c.setRepeatCount(Animation.INFINITE);
    txt.clearAnimation();
    txt.startAnimation(c);

    // ------------------------------------------------------------------------------------------
    // Used vars declaration
    // ------------------------------------------------------------------------------------------
    PieDetailsItem Item;
    Random mNumGen = new Random();
    int MaxPieItems = mNumGen.nextInt(20);
    Log.d("Sub", Integer.toString(MaxPieItems));
    int MaxCount = 0;
    int ItemCount = 0;
    String line;
    String dist_walk_FileName = "smallDistance";
    String storageDir = "/mnt/sdcard/Android/data";
    File dist_walk_File = new File(storageDir, dist_walk_FileName);

    try {
      BufferedReader br = new BufferedReader(new FileReader(dist_walk_File));

      while ((line = br.readLine()) != null) {
        ItemCount += Integer.parseInt(line);
      }
    } catch (FileNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (NumberFormatException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

    ItemCount = (int) sustainability_v2.sum_smallDistance;
    Log.d("small", Integer.toString(ItemCount) + "daily");
    Item = new PieDetailsItem();
    Item.Count = ItemCount;
    Item.Label = "Valeur " + mNumGen.nextInt(1000);
    Item.Color = 0xff33CC33;
    PieData.add(Item);
    MaxCount += ItemCount;
    ItemCount = (int) sustainability_v2.sum_largeDistance;
    Item = new PieDetailsItem();
    Item.Count = ItemCount;
    Log.d("large", Integer.toString(ItemCount));
    Item.Label = "Valeur " + mNumGen.nextInt(1000);
    Item.Color = 0xffFF3333;
    PieData.add(Item);
    MaxCount += ItemCount;
    Log.d("Count-Item", Integer.toString(MaxCount));

    // ------------------------------------------------------------------------------------------
    // Size => Pie size
    // ------------------------------------------------------------------------------------------
    int Size = 400;
    // ------------------------------------------------------------------------------------------
    // BgColor  => The background Pie Color
    // ------------------------------------------------------------------------------------------
    int BgColor = 0xff336699;
    // ------------------------------------------------------------------------------------------
    // mBackgroundImage  => Temporary image will be drawn with the content of pie view
    // ------------------------------------------------------------------------------------------
    Bitmap mBackgroundImage = Bitmap.createBitmap(Size, Size, Bitmap.Config.RGB_565);
    // ------------------------------------------------------------------------------------------
    // Generating Pie view
    // ------------------------------------------------------------------------------------------
    View_PieChart PieChartView = new View_PieChart(this);
    PieChartView.setLayoutParams(
        new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT));
    PieChartView.setGeometry(Size, Size, 2, 2, 1, 2);
    PieChartView.setSkinParams(BgColor);
    PieChartView.setData(PieData, MaxCount);
    PieChartView.invalidate();
    // ------------------------------------------------------------------------------------------
    // Draw Pie Vien on Bitmap canvas
    // ------------------------------------------------------------------------------------------
    PieChartView.draw(new Canvas(mBackgroundImage));
    PieChartView = null;
    // ------------------------------------------------------------------------------------------
    // Create a new ImageView to add to main layout
    // ------------------------------------------------------------------------------------------
    ImageView mImageView = new ImageView(this);
    mImageView.setLayoutParams(
        new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT));
    mImageView.setBackgroundColor(BgColor);
    mImageView.setImageBitmap(mBackgroundImage);
    // ------------------------------------------------------------------------------------------
    // Finaly add Image View to target view !!!
    // ------------------------------------------------------------------------------------------

    LinearLayout TargetPieView = (LinearLayout) findViewById(R.id.pie_container);
    TargetPieView.addView(mImageView);
  }
Exemplo n.º 11
0
  /*
   ** set animation of picture when it is changing
   */
  public void setPicAnimation(char direction) {

    switch (direction) {
      case 'R':
        {
          if (index < NUMPIC - 1) {
            index += 1;
          } else {
            index = 0;
          }

          this.viewFlipper.setInAnimation(AnimationUtils.loadAnimation(this, R.anim.push_left_in));
          this.viewFlipper.setOutAnimation(
              AnimationUtils.loadAnimation(this, R.anim.push_left_out));
          this.viewFlipper.showNext();
        }
        break;

      case 'L':
        {
          if (index > 0) {
            index -= 1;
          } else {
            index = NUMPIC - 1;
          }

          this.viewFlipper.setInAnimation(AnimationUtils.loadAnimation(this, R.anim.push_right_in));
          this.viewFlipper.setOutAnimation(
              AnimationUtils.loadAnimation(this, R.anim.push_right_out));
          this.viewFlipper.showPrevious();
        }
        break;

      default:
        break;
    }

    try {
      poem.setText(picText[index]); // change the text of the poem
      poem.startAnimation(AnimationUtils.loadAnimation(MainActivity.this, R.anim.scale_anim));

      if (index == NUMPIC - 1) {
        text1.setVisibility(View.VISIBLE);
        text2.setVisibility(View.VISIBLE);
        text3.setVisibility(View.VISIBLE);
        text1.startAnimation(
            AnimationUtils.loadAnimation(MainActivity.this, R.anim.translate_anim1));
        text2.startAnimation(
            AnimationUtils.loadAnimation(MainActivity.this, R.anim.translate_anim2));
        text3.startAnimation(
            AnimationUtils.loadAnimation(MainActivity.this, R.anim.translate_anim3));
      } else if (index == 0 || index == (NUMPIC - 2)) {
        text1.clearAnimation();
        text2.clearAnimation();
        text3.clearAnimation();
        text1.setVisibility(View.INVISIBLE);
        text2.setVisibility(View.INVISIBLE);
        text3.setVisibility(View.INVISIBLE);
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }