예제 #1
0
  @Override
  protected ModelAndView handleRequestInternal(
      HttpServletRequest request, HttpServletResponse response) throws Exception {

    User user = securityService.getCurrentUser(request);
    UserSettings userSettings = settingsService.getUserSettings(user.getUsername());
    Player player = playerService.getPlayer(request, response);

    Map<String, Object> map = new HashMap<String, Object>();
    map.put("user", user);
    map.put("player", player);
    map.put("players", playerService.getPlayersForUserAndClientId(user.getUsername(), null));
    map.put("visibility", userSettings.getPlaylistVisibility());
    map.put("partyMode", userSettings.isPartyModeEnabled());
    ModelAndView result = super.handleRequestInternal(request, response);
    result.addObject("model", map);
    return result;
  }
예제 #2
0
  public ModelAndView playlist(HttpServletRequest request, HttpServletResponse response)
      throws Exception {
    // Create array of players to control. If the "player" attribute is set for this session,
    // only the player with this ID is controlled.  Otherwise, all players are controlled.
    List<Player> players = playerService.getAllPlayers();

    String playerId = (String) request.getSession().getAttribute("player");
    if (playerId != null) {
      Player player = playerService.getPlayerById(playerId);
      if (player != null) {
        players = Arrays.asList(player);
      }
    }

    Map<String, Object> map = new HashMap<String, Object>();

    for (Player player : players) {
      Playlist playlist = player.getPlaylist();
      map.put("playlist", playlist);

      if (request.getParameter("play") != null) {
        MediaFile file = mediaFileService.getMediaFile(request.getParameter("play"));
        playlist.addFiles(false, file);
      } else if (request.getParameter("add") != null) {
        MediaFile file = mediaFileService.getMediaFile(request.getParameter("add"));
        playlist.addFiles(true, file);
      } else if (request.getParameter("skip") != null) {
        playlist.setIndex(Integer.parseInt(request.getParameter("skip")));
      } else if (request.getParameter("clear") != null) {
        playlist.clear();
      } else if (request.getParameter("load") != null) {
        playlistService.loadPlaylist(playlist, request.getParameter("load"));
      } else if (request.getParameter("random") != null) {
        List<MediaFile> randomFiles =
            searchService.getRandomSongs(new RandomSearchCriteria(20, null, null, null, null));
        playlist.addFiles(false, randomFiles);
      }
    }

    map.put("players", players);
    return new ModelAndView("wap/playlist", "model", map);
  }
예제 #3
0
  public ModelAndView settings(HttpServletRequest request, HttpServletResponse response)
      throws Exception {
    String playerId = (String) request.getSession().getAttribute("player");

    List<Player> allPlayers = playerService.getAllPlayers();
    User user = securityService.getCurrentUser(request);
    List<Player> players = new ArrayList<Player>();
    Map<String, Object> map = new HashMap<String, Object>();

    for (Player player : allPlayers) {
      // Only display authorized players.
      if (user.isAdminRole() || user.getUsername().equals(player.getUsername())) {
        players.add(player);
      }
    }
    map.put("playerId", playerId);
    map.put("players", players);
    return new ModelAndView("wap/settings", "model", map);
  }
  @Override
  protected ModelAndView handleRequestInternal(
      HttpServletRequest request, HttpServletResponse response) throws Exception {

    Map<String, Object> map = new HashMap<String, Object>();

    String pathInfo = request.getPathInfo();

    if (pathInfo == null || !pathInfo.startsWith("/")) {
      response.sendError(HttpServletResponse.SC_NOT_FOUND);
      return null;
    }

    Share share = shareService.getShareByName(pathInfo.substring(1));

    if (share != null && share.getExpires() != null && share.getExpires().before(new Date())) {
      share = null;
    }

    if (share != null) {
      share.setLastVisited(new Date());
      share.setVisitCount(share.getVisitCount() + 1);
      shareService.updateShare(share);
    }

    Player player = playerService.getGuestPlayer(request);

    map.put("share", share);
    map.put("entries", getEntries(share, player));
    map.put("redirectUrl", settingsService.getUrlRedirectUrl());
    map.put("player", player.getId());

    ModelAndView result = super.handleRequestInternal(request, response);
    result.addObject("model", map);
    return result;
  }
  protected ModelAndView handleRequestInternal(
      HttpServletRequest request, HttpServletResponse response) throws Exception {

    Map<String, Object> map = new HashMap<String, Object>();

    //	String id = request.getParameter("id");
    //  MediaFile mediaFile = mediaFileService.getMediaFile(path);

    int listOffset = DEFAULT_LIST_OFFSET;
    int listSize = DEFAULT_LIST_SIZE;
    String listType = DEFAULT_LIST_TYPE;

    User user = securityService.getCurrentUser(request);
    String username = user.getUsername();
    UserSettings userSettings = settingsService.getUserSettings(username);
    int userGroupId = securityService.getCurrentUserGroupId(request);

    if (request.getParameter("listOffset") != null) {
      listOffset =
          Math.max(
              0, Math.min(Integer.parseInt(request.getParameter("listOffset")), MAX_LIST_OFFSET));
    }

    if (request.getParameter("listSize") != null) {
      listSize =
          Math.max(0, Math.min(Integer.parseInt(request.getParameter("listSize")), MAX_LIST_SIZE));
    }

    if (request.getParameter("listType") != null) {
      listType = String.valueOf(request.getParameter("listType"));
    }
    List<MediaFile> songs;
    if ("topplayed".equals(listType)) {
      songs = mediaFileDao.getTopPlayedCountForUser(listOffset, listSize, username);
    } else if ("otheruser".equals(listType)) {
      songs = mediaFileDao.getLastPlayedCountForAllUser(listOffset, listSize, userGroupId);
    } else if ("overall".equals(listType)) {
      songs = mediaFileDao.getTopPlayedCountForAllUser(listOffset, listSize, userGroupId);
    } else if ("lastplayed".equals(listType)) {
      songs = mediaFileDao.getLastPlayedCountForUser(listOffset, listSize, username);
    } else {
      songs = mediaFileDao.getLastPlayedCountForAllUser(0, 1, userGroupId);
    }

    mediaFileService.populateStarredDate(songs, username);
    map.put("user", user);
    map.put("songs", songs);

    map.put("partyModeEnabled", userSettings.isPartyModeEnabled());
    map.put("player", playerService.getPlayer(request, response));

    map.put("listOffset", listOffset);
    map.put("listSize", listSize);
    map.put("listType", listType);

    //  map.put("starred", mediaFileService.getMediaFileStarredDate(dir.getId(), username) != null);

    ModelAndView result = super.handleRequestInternal(request, response);
    result.addObject("model", map);
    return result;
  }
  public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response)
      throws Exception {

    TransferStatus status = null;
    PlayQueueInputStream in = null;
    Player player = playerService.getPlayer(request, response, false, true);
    User user = securityService.getUserByName(player.getUsername());

    try {

      if (!user.isStreamRole()) {
        response.sendError(
            HttpServletResponse.SC_FORBIDDEN,
            "Streaming is forbidden for user " + user.getUsername());
        return null;
      }

      // If "playlist" request parameter is set, this is a Podcast request. In that case, create a
      // separate
      // play queue (in order to support multiple parallel Podcast streams).
      Integer playlistId = ServletRequestUtils.getIntParameter(request, "playlist");
      boolean isPodcast = playlistId != null;
      if (isPodcast) {
        PlayQueue playQueue = new PlayQueue();
        playQueue.addFiles(false, playlistService.getFilesInPlaylist(playlistId));
        player.setPlayQueue(playQueue);
        Util.setContentLength(response, playQueue.length());
        LOG.info("Incoming Podcast request for playlist " + playlistId);
      }

      String contentType = StringUtil.getMimeType(request.getParameter("suffix"));
      response.setContentType(contentType);

      String preferredTargetFormat = request.getParameter("format");
      Integer maxBitRate = ServletRequestUtils.getIntParameter(request, "maxBitRate");
      if (Integer.valueOf(0).equals(maxBitRate)) {
        maxBitRate = null;
      }

      VideoTranscodingSettings videoTranscodingSettings = null;

      // Is this a request for a single file (typically from the embedded Flash player)?
      // In that case, create a separate playlist (in order to support multiple parallel streams).
      // Also, enable partial download (HTTP byte range).
      MediaFile file = getSingleFile(request);
      boolean isSingleFile = file != null;
      LongRange range = null;

      if (isSingleFile) {
        PlayQueue playQueue = new PlayQueue();
        playQueue.addFiles(true, file);
        player.setPlayQueue(playQueue);

        if (!file.isVideo()) {
          response.setIntHeader("ETag", file.getId());
          //          response.setHeader("Accept-Ranges", "bytes");
        }

        TranscodingService.Parameters parameters =
            transcodingService.getParameters(
                file, player, maxBitRate, preferredTargetFormat, null, false);
        long fileLength = getFileLength(parameters);
        boolean isConversion = parameters.isDownsample() || parameters.isTranscode();
        boolean estimateContentLength =
            ServletRequestUtils.getBooleanParameter(request, "estimateContentLength", false);
        boolean isHls = ServletRequestUtils.getBooleanParameter(request, "hls", false);

        range = getRange(request, file);
        if (range != null) {
          LOG.info("Got range: " + range);

          //                    response.setStatus(HttpServletResponse.SC_PARTIAL_CONTENT);
          //                    Util.setContentLength(response, fileLength -
          // range.getMinimumLong());
          //                    long firstBytePos = range.getMinimumLong();
          //                    long lastBytePos = fileLength - 1;
          //                    response.setHeader("Content-Range", "bytes " + firstBytePos + "-" +
          // lastBytePos + "/" + fileLength);

          ///
          if (isConversion) {
            response.setHeader("Accept-Ranges", "none");
          } else {
            response.setStatus(HttpServletResponse.SC_PARTIAL_CONTENT);
            long maxLength = fileLength;
            if (maxLength > range.getMaximumLong()) maxLength = range.getMaximumLong() + 1;
            Util.setContentLength(response, Math.max(maxLength - range.getMinimumLong(), 0));
            long firstBytePos = range.getMinimumLong();
            long lastBytePos = maxLength - 1;
            response.setHeader(
                "Content-Range", "bytes " + firstBytePos + "-" + lastBytePos + "/" + fileLength);
          }
          ///
        } else if (!isHls && (!isConversion || estimateContentLength)) {
          Util.setContentLength(response, fileLength);
        }

        if (isHls) {
          response.setContentType(StringUtil.getMimeType("ts")); // HLS is always MPEG TS.
        } else {
          String transcodedSuffix =
              transcodingService.getSuffix(player, file, preferredTargetFormat);
          response.setContentType(StringUtil.getMimeType(transcodedSuffix));
        }

        if (file.isVideo() || isHls) {
          videoTranscodingSettings = createVideoTranscodingSettings(file, request);
        }
      }

      if (request.getMethod().equals("HEAD")) {
        return null;
      }

      // Terminate any other streams to this player.
      if (!isPodcast && !isSingleFile) {
        for (TransferStatus streamStatus : statusService.getStreamStatusesForPlayer(player)) {
          if (streamStatus.isActive()) {
            streamStatus.terminate();
          }
        }
      }

      status = statusService.createStreamStatus(player);

      in =
          new PlayQueueInputStream(
              player,
              status,
              maxBitRate,
              preferredTargetFormat,
              videoTranscodingSettings,
              transcodingService,
              audioScrobblerService,
              mediaFileService,
              searchService);
      OutputStream out = RangeOutputStream.wrap(response.getOutputStream(), range);

      // Enabled SHOUTcast, if requested.
      boolean isShoutCastRequested = "1".equals(request.getHeader("icy-metadata"));
      if (isShoutCastRequested && !isSingleFile) {
        response.setHeader("icy-metaint", "" + ShoutCastOutputStream.META_DATA_INTERVAL);
        response.setHeader("icy-notice1", "This stream is served using FutureSonic");
        response.setHeader("icy-notice2", "FutureSonic - Free media streamer - sonic.lt");
        response.setHeader("icy-name", "FutureSonic");
        response.setHeader("icy-genre", "Mixed");
        response.setHeader("icy-url", "http://sonic.lt/");
        out = new ShoutCastOutputStream(out, player.getPlayQueue(), settingsService);
      }

      final int BUFFER_SIZE = 2048;
      byte[] buf = new byte[BUFFER_SIZE];

      while (true) {

        // Check if stream has been terminated.
        if (status.terminated()) {
          return null;
        }

        if (player.getPlayQueue().getStatus() == PlayQueue.Status.STOPPED) {
          if (isPodcast || isSingleFile) {
            break;
          } else {
            sendDummy(buf, out);
          }
        } else {

          int n = in.read(buf);
          if (n == -1) {
            if (isPodcast || isSingleFile) {
              break;
            } else {
              sendDummy(buf, out);
            }
          } else {
            out.write(buf, 0, n);
          }
        }
      }

    } finally {
      if (status != null) {
        securityService.updateUserByteCounts(user, status.getBytesTransfered(), 0L, 0L);
        statusService.removeStreamStatus(status);
      }
      IOUtils.closeQuietly(in);
    }
    return null;
  }
예제 #7
0
  @Override
  protected ModelAndView handleRequestInternal(
      HttpServletRequest request, HttpServletResponse response) throws Exception {
    Map<String, Object> map = new HashMap<String, Object>();

    Player player = playerService.getPlayer(request, response);
    List<MediaFile> mediaFiles = getMediaFiles(request);

    if (mediaFiles.isEmpty()) {
      return new ModelAndView(new RedirectView("notFound.view"));
    }

    MediaFile dir = mediaFiles.get(0);
    if (dir.isFile()) {
      dir = mediaFileService.getParentOf(dir);
    }

    // Redirect if root directory.
    if (mediaFileService.isRoot(dir)) {
      return new ModelAndView(new RedirectView("home.view?"));
    }

    List<MediaFile> children =
        mediaFiles.size() == 1
            ? mediaFileService.getChildrenOf(dir, true, true, true)
            : getMultiFolderChildren(mediaFiles);
    String username = securityService.getCurrentUsername(request);
    UserSettings userSettings = settingsService.getUserSettings(username);

    mediaFileService.populateStarredDate(dir, username);
    mediaFileService.populateStarredDate(children, username);

    map.put("dir", dir);
    map.put("ancestors", getAncestors(dir));
    map.put("children", children);
    map.put("artist", guessArtist(children));
    map.put("album", guessAlbum(children));
    map.put("player", player);
    map.put("sieblingCoverArtScheme", CoverArtScheme.SMALL);
    map.put("user", securityService.getCurrentUser(request));
    map.put("visibility", userSettings.getMainVisibility());
    map.put("showAlbumYear", settingsService.isSortAlbumsByYear());
    map.put("updateNowPlaying", request.getParameter("updateNowPlaying") != null);
    map.put("partyMode", userSettings.isPartyModeEnabled());
    map.put("brand", settingsService.getBrand());

    try {
      MediaFile parent = mediaFileService.getParentOf(dir);
      map.put("parent", parent);
      map.put("navigateUpAllowed", !mediaFileService.isRoot(parent));
    } catch (SecurityException x) {
      // Happens if Podcast directory is outside music folder.
    }

    Integer userRating = ratingService.getRatingForUser(username, dir);
    Double averageRating = ratingService.getAverageRating(dir);

    if (userRating == null) {
      userRating = 0;
    }

    if (averageRating == null) {
      averageRating = 0.0D;
    }

    map.put("userRating", 10 * userRating);
    map.put("averageRating", Math.round(10.0D * averageRating));
    map.put("starred", mediaFileService.getMediaFileStarredDate(dir.getId(), username) != null);

    CoverArtScheme scheme = player.getCoverArtScheme();
    if (scheme != CoverArtScheme.OFF) {
      List<MediaFile> coverArts = getCoverArts(dir, children);
      map.put("coverArts", coverArts);
      setSieblingAlbums(dir, map);
    }

    ModelAndView result = super.handleRequestInternal(request, response);
    result.addObject("model", map);
    return result;
  }